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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,800
|
heroku/heroku.py
|
heroku/models.py
|
App.domains
|
def domains(self):
"""The domains for this app."""
return self._h._get_resources(
resource=('apps', self.name, 'domains'),
obj=Domain, app=self
)
|
python
|
def domains(self):
"""The domains for this app."""
return self._h._get_resources(
resource=('apps', self.name, 'domains'),
obj=Domain, app=self
)
|
[
"def",
"domains",
"(",
"self",
")",
":",
"return",
"self",
".",
"_h",
".",
"_get_resources",
"(",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'domains'",
")",
",",
"obj",
"=",
"Domain",
",",
"app",
"=",
"self",
")"
] |
The domains for this app.
|
[
"The",
"domains",
"for",
"this",
"app",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L222-L227
|
11,801
|
heroku/heroku.py
|
heroku/models.py
|
App.releases
|
def releases(self):
"""The releases for this app."""
return self._h._get_resources(
resource=('apps', self.name, 'releases'),
obj=Release, app=self
)
|
python
|
def releases(self):
"""The releases for this app."""
return self._h._get_resources(
resource=('apps', self.name, 'releases'),
obj=Release, app=self
)
|
[
"def",
"releases",
"(",
"self",
")",
":",
"return",
"self",
".",
"_h",
".",
"_get_resources",
"(",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'releases'",
")",
",",
"obj",
"=",
"Release",
",",
"app",
"=",
"self",
")"
] |
The releases for this app.
|
[
"The",
"releases",
"for",
"this",
"app",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L230-L235
|
11,802
|
heroku/heroku.py
|
heroku/models.py
|
App.processes
|
def processes(self):
"""The proccesses for this app."""
return self._h._get_resources(
resource=('apps', self.name, 'ps'),
obj=Process, app=self, map=ProcessListResource
)
|
python
|
def processes(self):
"""The proccesses for this app."""
return self._h._get_resources(
resource=('apps', self.name, 'ps'),
obj=Process, app=self, map=ProcessListResource
)
|
[
"def",
"processes",
"(",
"self",
")",
":",
"return",
"self",
".",
"_h",
".",
"_get_resources",
"(",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'ps'",
")",
",",
"obj",
"=",
"Process",
",",
"app",
"=",
"self",
",",
"map",
"=",
"ProcessListResource",
")"
] |
The proccesses for this app.
|
[
"The",
"proccesses",
"for",
"this",
"app",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L238-L243
|
11,803
|
heroku/heroku.py
|
heroku/models.py
|
App.config
|
def config(self):
"""The envs for this app."""
return self._h._get_resource(
resource=('apps', self.name, 'config_vars'),
obj=ConfigVars, app=self
)
|
python
|
def config(self):
"""The envs for this app."""
return self._h._get_resource(
resource=('apps', self.name, 'config_vars'),
obj=ConfigVars, app=self
)
|
[
"def",
"config",
"(",
"self",
")",
":",
"return",
"self",
".",
"_h",
".",
"_get_resource",
"(",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'config_vars'",
")",
",",
"obj",
"=",
"ConfigVars",
",",
"app",
"=",
"self",
")"
] |
The envs for this app.
|
[
"The",
"envs",
"for",
"this",
"app",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L246-L252
|
11,804
|
heroku/heroku.py
|
heroku/models.py
|
App.info
|
def info(self):
"""Returns current info for this app."""
return self._h._get_resource(
resource=('apps', self.name),
obj=App,
)
|
python
|
def info(self):
"""Returns current info for this app."""
return self._h._get_resource(
resource=('apps', self.name),
obj=App,
)
|
[
"def",
"info",
"(",
"self",
")",
":",
"return",
"self",
".",
"_h",
".",
"_get_resource",
"(",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
")",
",",
"obj",
"=",
"App",
",",
")"
] |
Returns current info for this app.
|
[
"Returns",
"current",
"info",
"for",
"this",
"app",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L255-L261
|
11,805
|
heroku/heroku.py
|
heroku/models.py
|
App.rollback
|
def rollback(self, release):
"""Rolls back the release to the given version."""
r = self._h._http_resource(
method='POST',
resource=('apps', self.name, 'releases'),
data={'rollback': release}
)
return self.releases[-1]
|
python
|
def rollback(self, release):
"""Rolls back the release to the given version."""
r = self._h._http_resource(
method='POST',
resource=('apps', self.name, 'releases'),
data={'rollback': release}
)
return self.releases[-1]
|
[
"def",
"rollback",
"(",
"self",
",",
"release",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'POST'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'releases'",
")",
",",
"data",
"=",
"{",
"'rollback'",
":",
"release",
"}",
")",
"return",
"self",
".",
"releases",
"[",
"-",
"1",
"]"
] |
Rolls back the release to the given version.
|
[
"Rolls",
"back",
"the",
"release",
"to",
"the",
"given",
"version",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L270-L277
|
11,806
|
heroku/heroku.py
|
heroku/models.py
|
App.rename
|
def rename(self, name):
"""Renames app to given name."""
r = self._h._http_resource(
method='PUT',
resource=('apps', self.name),
data={'app[name]': name}
)
return r.ok
|
python
|
def rename(self, name):
"""Renames app to given name."""
r = self._h._http_resource(
method='PUT',
resource=('apps', self.name),
data={'app[name]': name}
)
return r.ok
|
[
"def",
"rename",
"(",
"self",
",",
"name",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'PUT'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
")",
",",
"data",
"=",
"{",
"'app[name]'",
":",
"name",
"}",
")",
"return",
"r",
".",
"ok"
] |
Renames app to given name.
|
[
"Renames",
"app",
"to",
"given",
"name",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L280-L288
|
11,807
|
heroku/heroku.py
|
heroku/models.py
|
App.transfer
|
def transfer(self, user):
"""Transfers app to given username's account."""
r = self._h._http_resource(
method='PUT',
resource=('apps', self.name),
data={'app[transfer_owner]': user}
)
return r.ok
|
python
|
def transfer(self, user):
"""Transfers app to given username's account."""
r = self._h._http_resource(
method='PUT',
resource=('apps', self.name),
data={'app[transfer_owner]': user}
)
return r.ok
|
[
"def",
"transfer",
"(",
"self",
",",
"user",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'PUT'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
")",
",",
"data",
"=",
"{",
"'app[transfer_owner]'",
":",
"user",
"}",
")",
"return",
"r",
".",
"ok"
] |
Transfers app to given username's account.
|
[
"Transfers",
"app",
"to",
"given",
"username",
"s",
"account",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L290-L298
|
11,808
|
heroku/heroku.py
|
heroku/models.py
|
App.maintenance
|
def maintenance(self, on=True):
"""Toggles maintenance mode."""
r = self._h._http_resource(
method='POST',
resource=('apps', self.name, 'server', 'maintenance'),
data={'maintenance_mode': int(on)}
)
return r.ok
|
python
|
def maintenance(self, on=True):
"""Toggles maintenance mode."""
r = self._h._http_resource(
method='POST',
resource=('apps', self.name, 'server', 'maintenance'),
data={'maintenance_mode': int(on)}
)
return r.ok
|
[
"def",
"maintenance",
"(",
"self",
",",
"on",
"=",
"True",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'POST'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'server'",
",",
"'maintenance'",
")",
",",
"data",
"=",
"{",
"'maintenance_mode'",
":",
"int",
"(",
"on",
")",
"}",
")",
"return",
"r",
".",
"ok"
] |
Toggles maintenance mode.
|
[
"Toggles",
"maintenance",
"mode",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L300-L308
|
11,809
|
heroku/heroku.py
|
heroku/models.py
|
App.destroy
|
def destroy(self):
"""Destoys the app. Do be careful."""
r = self._h._http_resource(
method='DELETE',
resource=('apps', self.name)
)
return r.ok
|
python
|
def destroy(self):
"""Destoys the app. Do be careful."""
r = self._h._http_resource(
method='DELETE',
resource=('apps', self.name)
)
return r.ok
|
[
"def",
"destroy",
"(",
"self",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'DELETE'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
")",
")",
"return",
"r",
".",
"ok"
] |
Destoys the app. Do be careful.
|
[
"Destoys",
"the",
"app",
".",
"Do",
"be",
"careful",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L310-L317
|
11,810
|
heroku/heroku.py
|
heroku/models.py
|
App.logs
|
def logs(self, num=None, source=None, ps=None, tail=False):
"""Returns the requested log."""
# Bootstrap payload package.
payload = {'logplex': 'true'}
if num:
payload['num'] = num
if source:
payload['source'] = source
if ps:
payload['ps'] = ps
if tail:
payload['tail'] = 1
# Grab the URL of the logplex endpoint.
r = self._h._http_resource(
method='GET',
resource=('apps', self.name, 'logs'),
data=payload
)
# Grab the actual logs.
r = requests.get(r.content.decode("utf-8"), verify=False, stream=True)
if not tail:
return r.content
else:
# Return line iterator for tail!
return r.iter_lines()
|
python
|
def logs(self, num=None, source=None, ps=None, tail=False):
"""Returns the requested log."""
# Bootstrap payload package.
payload = {'logplex': 'true'}
if num:
payload['num'] = num
if source:
payload['source'] = source
if ps:
payload['ps'] = ps
if tail:
payload['tail'] = 1
# Grab the URL of the logplex endpoint.
r = self._h._http_resource(
method='GET',
resource=('apps', self.name, 'logs'),
data=payload
)
# Grab the actual logs.
r = requests.get(r.content.decode("utf-8"), verify=False, stream=True)
if not tail:
return r.content
else:
# Return line iterator for tail!
return r.iter_lines()
|
[
"def",
"logs",
"(",
"self",
",",
"num",
"=",
"None",
",",
"source",
"=",
"None",
",",
"ps",
"=",
"None",
",",
"tail",
"=",
"False",
")",
":",
"# Bootstrap payload package.",
"payload",
"=",
"{",
"'logplex'",
":",
"'true'",
"}",
"if",
"num",
":",
"payload",
"[",
"'num'",
"]",
"=",
"num",
"if",
"source",
":",
"payload",
"[",
"'source'",
"]",
"=",
"source",
"if",
"ps",
":",
"payload",
"[",
"'ps'",
"]",
"=",
"ps",
"if",
"tail",
":",
"payload",
"[",
"'tail'",
"]",
"=",
"1",
"# Grab the URL of the logplex endpoint.",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'GET'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"name",
",",
"'logs'",
")",
",",
"data",
"=",
"payload",
")",
"# Grab the actual logs.",
"r",
"=",
"requests",
".",
"get",
"(",
"r",
".",
"content",
".",
"decode",
"(",
"\"utf-8\"",
")",
",",
"verify",
"=",
"False",
",",
"stream",
"=",
"True",
")",
"if",
"not",
"tail",
":",
"return",
"r",
".",
"content",
"else",
":",
"# Return line iterator for tail!",
"return",
"r",
".",
"iter_lines",
"(",
")"
] |
Returns the requested log.
|
[
"Returns",
"the",
"requested",
"log",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L319-L351
|
11,811
|
heroku/heroku.py
|
heroku/models.py
|
Key.delete
|
def delete(self):
"""Deletes the key."""
r = self._h._http_resource(
method='DELETE',
resource=('user', 'keys', self.id)
)
r.raise_for_status()
|
python
|
def delete(self):
"""Deletes the key."""
r = self._h._http_resource(
method='DELETE',
resource=('user', 'keys', self.id)
)
r.raise_for_status()
|
[
"def",
"delete",
"(",
"self",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'DELETE'",
",",
"resource",
"=",
"(",
"'user'",
",",
"'keys'",
",",
"self",
".",
"id",
")",
")",
"r",
".",
"raise_for_status",
"(",
")"
] |
Deletes the key.
|
[
"Deletes",
"the",
"key",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L492-L499
|
11,812
|
heroku/heroku.py
|
heroku/models.py
|
Process.restart
|
def restart(self, all=False):
"""Restarts the given process."""
if all:
data = {'type': self.type}
else:
data = {'ps': self.process}
r = self._h._http_resource(
method='POST',
resource=('apps', self.app.name, 'ps', 'restart'),
data=data
)
r.raise_for_status()
|
python
|
def restart(self, all=False):
"""Restarts the given process."""
if all:
data = {'type': self.type}
else:
data = {'ps': self.process}
r = self._h._http_resource(
method='POST',
resource=('apps', self.app.name, 'ps', 'restart'),
data=data
)
r.raise_for_status()
|
[
"def",
"restart",
"(",
"self",
",",
"all",
"=",
"False",
")",
":",
"if",
"all",
":",
"data",
"=",
"{",
"'type'",
":",
"self",
".",
"type",
"}",
"else",
":",
"data",
"=",
"{",
"'ps'",
":",
"self",
".",
"process",
"}",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'POST'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"app",
".",
"name",
",",
"'ps'",
",",
"'restart'",
")",
",",
"data",
"=",
"data",
")",
"r",
".",
"raise_for_status",
"(",
")"
] |
Restarts the given process.
|
[
"Restarts",
"the",
"given",
"process",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L547-L562
|
11,813
|
heroku/heroku.py
|
heroku/models.py
|
Process.scale
|
def scale(self, quantity):
"""Scales the given process to the given number of dynos."""
r = self._h._http_resource(
method='POST',
resource=('apps', self.app.name, 'ps', 'scale'),
data={'type': self.type, 'qty': quantity}
)
r.raise_for_status()
try:
return self.app.processes[self.type]
except KeyError:
return ProcessListResource()
|
python
|
def scale(self, quantity):
"""Scales the given process to the given number of dynos."""
r = self._h._http_resource(
method='POST',
resource=('apps', self.app.name, 'ps', 'scale'),
data={'type': self.type, 'qty': quantity}
)
r.raise_for_status()
try:
return self.app.processes[self.type]
except KeyError:
return ProcessListResource()
|
[
"def",
"scale",
"(",
"self",
",",
"quantity",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'POST'",
",",
"resource",
"=",
"(",
"'apps'",
",",
"self",
".",
"app",
".",
"name",
",",
"'ps'",
",",
"'scale'",
")",
",",
"data",
"=",
"{",
"'type'",
":",
"self",
".",
"type",
",",
"'qty'",
":",
"quantity",
"}",
")",
"r",
".",
"raise_for_status",
"(",
")",
"try",
":",
"return",
"self",
".",
"app",
".",
"processes",
"[",
"self",
".",
"type",
"]",
"except",
"KeyError",
":",
"return",
"ProcessListResource",
"(",
")"
] |
Scales the given process to the given number of dynos.
|
[
"Scales",
"the",
"given",
"process",
"to",
"the",
"given",
"number",
"of",
"dynos",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/models.py#L581-L595
|
11,814
|
heroku/heroku.py
|
heroku/helpers.py
|
is_collection
|
def is_collection(obj):
"""Tests if an object is a collection."""
col = getattr(obj, '__getitem__', False)
val = False if (not col) else True
if isinstance(obj, basestring):
val = False
return val
|
python
|
def is_collection(obj):
"""Tests if an object is a collection."""
col = getattr(obj, '__getitem__', False)
val = False if (not col) else True
if isinstance(obj, basestring):
val = False
return val
|
[
"def",
"is_collection",
"(",
"obj",
")",
":",
"col",
"=",
"getattr",
"(",
"obj",
",",
"'__getitem__'",
",",
"False",
")",
"val",
"=",
"False",
"if",
"(",
"not",
"col",
")",
"else",
"True",
"if",
"isinstance",
"(",
"obj",
",",
"basestring",
")",
":",
"val",
"=",
"False",
"return",
"val"
] |
Tests if an object is a collection.
|
[
"Tests",
"if",
"an",
"object",
"is",
"a",
"collection",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/helpers.py#L19-L28
|
11,815
|
heroku/heroku.py
|
heroku/helpers.py
|
to_python
|
def to_python(obj,
in_dict,
str_keys=None,
date_keys=None,
int_keys=None,
object_map=None,
bool_keys=None,
dict_keys=None,
**kwargs):
"""Extends a given object for API Consumption.
:param obj: Object to extend.
:param in_dict: Dict to extract data from.
:param string_keys: List of in_dict keys that will be extracted as strings.
:param date_keys: List of in_dict keys that will be extrad as datetimes.
:param object_map: Dict of {key, obj} map, for nested object results.
"""
d = dict()
if str_keys:
for in_key in str_keys:
d[in_key] = in_dict.get(in_key)
if date_keys:
for in_key in date_keys:
in_date = in_dict.get(in_key)
try:
out_date = parse_datetime(in_date)
except TypeError as e:
raise e
out_date = None
d[in_key] = out_date
if int_keys:
for in_key in int_keys:
if (in_dict is not None) and (in_dict.get(in_key) is not None):
d[in_key] = int(in_dict.get(in_key))
if bool_keys:
for in_key in bool_keys:
if in_dict.get(in_key) is not None:
d[in_key] = bool(in_dict.get(in_key))
if dict_keys:
for in_key in dict_keys:
if in_dict.get(in_key) is not None:
d[in_key] = dict(in_dict.get(in_key))
if object_map:
for (k, v) in object_map.items():
if in_dict.get(k):
d[k] = v.new_from_dict(in_dict.get(k))
obj.__dict__.update(d)
obj.__dict__.update(kwargs)
# Save the dictionary, for write comparisons.
# obj._cache = d
# obj.__cache = in_dict
return obj
|
python
|
def to_python(obj,
in_dict,
str_keys=None,
date_keys=None,
int_keys=None,
object_map=None,
bool_keys=None,
dict_keys=None,
**kwargs):
"""Extends a given object for API Consumption.
:param obj: Object to extend.
:param in_dict: Dict to extract data from.
:param string_keys: List of in_dict keys that will be extracted as strings.
:param date_keys: List of in_dict keys that will be extrad as datetimes.
:param object_map: Dict of {key, obj} map, for nested object results.
"""
d = dict()
if str_keys:
for in_key in str_keys:
d[in_key] = in_dict.get(in_key)
if date_keys:
for in_key in date_keys:
in_date = in_dict.get(in_key)
try:
out_date = parse_datetime(in_date)
except TypeError as e:
raise e
out_date = None
d[in_key] = out_date
if int_keys:
for in_key in int_keys:
if (in_dict is not None) and (in_dict.get(in_key) is not None):
d[in_key] = int(in_dict.get(in_key))
if bool_keys:
for in_key in bool_keys:
if in_dict.get(in_key) is not None:
d[in_key] = bool(in_dict.get(in_key))
if dict_keys:
for in_key in dict_keys:
if in_dict.get(in_key) is not None:
d[in_key] = dict(in_dict.get(in_key))
if object_map:
for (k, v) in object_map.items():
if in_dict.get(k):
d[k] = v.new_from_dict(in_dict.get(k))
obj.__dict__.update(d)
obj.__dict__.update(kwargs)
# Save the dictionary, for write comparisons.
# obj._cache = d
# obj.__cache = in_dict
return obj
|
[
"def",
"to_python",
"(",
"obj",
",",
"in_dict",
",",
"str_keys",
"=",
"None",
",",
"date_keys",
"=",
"None",
",",
"int_keys",
"=",
"None",
",",
"object_map",
"=",
"None",
",",
"bool_keys",
"=",
"None",
",",
"dict_keys",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"d",
"=",
"dict",
"(",
")",
"if",
"str_keys",
":",
"for",
"in_key",
"in",
"str_keys",
":",
"d",
"[",
"in_key",
"]",
"=",
"in_dict",
".",
"get",
"(",
"in_key",
")",
"if",
"date_keys",
":",
"for",
"in_key",
"in",
"date_keys",
":",
"in_date",
"=",
"in_dict",
".",
"get",
"(",
"in_key",
")",
"try",
":",
"out_date",
"=",
"parse_datetime",
"(",
"in_date",
")",
"except",
"TypeError",
"as",
"e",
":",
"raise",
"e",
"out_date",
"=",
"None",
"d",
"[",
"in_key",
"]",
"=",
"out_date",
"if",
"int_keys",
":",
"for",
"in_key",
"in",
"int_keys",
":",
"if",
"(",
"in_dict",
"is",
"not",
"None",
")",
"and",
"(",
"in_dict",
".",
"get",
"(",
"in_key",
")",
"is",
"not",
"None",
")",
":",
"d",
"[",
"in_key",
"]",
"=",
"int",
"(",
"in_dict",
".",
"get",
"(",
"in_key",
")",
")",
"if",
"bool_keys",
":",
"for",
"in_key",
"in",
"bool_keys",
":",
"if",
"in_dict",
".",
"get",
"(",
"in_key",
")",
"is",
"not",
"None",
":",
"d",
"[",
"in_key",
"]",
"=",
"bool",
"(",
"in_dict",
".",
"get",
"(",
"in_key",
")",
")",
"if",
"dict_keys",
":",
"for",
"in_key",
"in",
"dict_keys",
":",
"if",
"in_dict",
".",
"get",
"(",
"in_key",
")",
"is",
"not",
"None",
":",
"d",
"[",
"in_key",
"]",
"=",
"dict",
"(",
"in_dict",
".",
"get",
"(",
"in_key",
")",
")",
"if",
"object_map",
":",
"for",
"(",
"k",
",",
"v",
")",
"in",
"object_map",
".",
"items",
"(",
")",
":",
"if",
"in_dict",
".",
"get",
"(",
"k",
")",
":",
"d",
"[",
"k",
"]",
"=",
"v",
".",
"new_from_dict",
"(",
"in_dict",
".",
"get",
"(",
"k",
")",
")",
"obj",
".",
"__dict__",
".",
"update",
"(",
"d",
")",
"obj",
".",
"__dict__",
".",
"update",
"(",
"kwargs",
")",
"# Save the dictionary, for write comparisons.",
"# obj._cache = d",
"# obj.__cache = in_dict",
"return",
"obj"
] |
Extends a given object for API Consumption.
:param obj: Object to extend.
:param in_dict: Dict to extract data from.
:param string_keys: List of in_dict keys that will be extracted as strings.
:param date_keys: List of in_dict keys that will be extrad as datetimes.
:param object_map: Dict of {key, obj} map, for nested object results.
|
[
"Extends",
"a",
"given",
"object",
"for",
"API",
"Consumption",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/helpers.py#L33-L95
|
11,816
|
heroku/heroku.py
|
heroku/helpers.py
|
to_api
|
def to_api(in_dict, int_keys=None, date_keys=None, bool_keys=None):
"""Extends a given object for API Production."""
# Cast all int_keys to int()
if int_keys:
for in_key in int_keys:
if (in_key in in_dict) and (in_dict.get(in_key, None) is not None):
in_dict[in_key] = int(in_dict[in_key])
# Cast all date_keys to datetime.isoformat
if date_keys:
for in_key in date_keys:
if (in_key in in_dict) and (in_dict.get(in_key, None) is not None):
_from = in_dict[in_key]
if isinstance(_from, basestring):
dtime = parse_datetime(_from)
elif isinstance(_from, datetime):
dtime = _from
in_dict[in_key] = dtime.isoformat()
elif (in_key in in_dict) and in_dict.get(in_key, None) is None:
del in_dict[in_key]
# Remove all Nones
for k, v in in_dict.items():
if v is None:
del in_dict[k]
return in_dict
|
python
|
def to_api(in_dict, int_keys=None, date_keys=None, bool_keys=None):
"""Extends a given object for API Production."""
# Cast all int_keys to int()
if int_keys:
for in_key in int_keys:
if (in_key in in_dict) and (in_dict.get(in_key, None) is not None):
in_dict[in_key] = int(in_dict[in_key])
# Cast all date_keys to datetime.isoformat
if date_keys:
for in_key in date_keys:
if (in_key in in_dict) and (in_dict.get(in_key, None) is not None):
_from = in_dict[in_key]
if isinstance(_from, basestring):
dtime = parse_datetime(_from)
elif isinstance(_from, datetime):
dtime = _from
in_dict[in_key] = dtime.isoformat()
elif (in_key in in_dict) and in_dict.get(in_key, None) is None:
del in_dict[in_key]
# Remove all Nones
for k, v in in_dict.items():
if v is None:
del in_dict[k]
return in_dict
|
[
"def",
"to_api",
"(",
"in_dict",
",",
"int_keys",
"=",
"None",
",",
"date_keys",
"=",
"None",
",",
"bool_keys",
"=",
"None",
")",
":",
"# Cast all int_keys to int()",
"if",
"int_keys",
":",
"for",
"in_key",
"in",
"int_keys",
":",
"if",
"(",
"in_key",
"in",
"in_dict",
")",
"and",
"(",
"in_dict",
".",
"get",
"(",
"in_key",
",",
"None",
")",
"is",
"not",
"None",
")",
":",
"in_dict",
"[",
"in_key",
"]",
"=",
"int",
"(",
"in_dict",
"[",
"in_key",
"]",
")",
"# Cast all date_keys to datetime.isoformat",
"if",
"date_keys",
":",
"for",
"in_key",
"in",
"date_keys",
":",
"if",
"(",
"in_key",
"in",
"in_dict",
")",
"and",
"(",
"in_dict",
".",
"get",
"(",
"in_key",
",",
"None",
")",
"is",
"not",
"None",
")",
":",
"_from",
"=",
"in_dict",
"[",
"in_key",
"]",
"if",
"isinstance",
"(",
"_from",
",",
"basestring",
")",
":",
"dtime",
"=",
"parse_datetime",
"(",
"_from",
")",
"elif",
"isinstance",
"(",
"_from",
",",
"datetime",
")",
":",
"dtime",
"=",
"_from",
"in_dict",
"[",
"in_key",
"]",
"=",
"dtime",
".",
"isoformat",
"(",
")",
"elif",
"(",
"in_key",
"in",
"in_dict",
")",
"and",
"in_dict",
".",
"get",
"(",
"in_key",
",",
"None",
")",
"is",
"None",
":",
"del",
"in_dict",
"[",
"in_key",
"]",
"# Remove all Nones",
"for",
"k",
",",
"v",
"in",
"in_dict",
".",
"items",
"(",
")",
":",
"if",
"v",
"is",
"None",
":",
"del",
"in_dict",
"[",
"k",
"]",
"return",
"in_dict"
] |
Extends a given object for API Production.
|
[
"Extends",
"a",
"given",
"object",
"for",
"API",
"Production",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/helpers.py#L99-L131
|
11,817
|
heroku/heroku.py
|
heroku/structures.py
|
SSHKeyListResource.clear
|
def clear(self):
"""Removes all SSH keys from a user's system."""
r = self._h._http_resource(
method='DELETE',
resource=('user', 'keys'),
)
return r.ok
|
python
|
def clear(self):
"""Removes all SSH keys from a user's system."""
r = self._h._http_resource(
method='DELETE',
resource=('user', 'keys'),
)
return r.ok
|
[
"def",
"clear",
"(",
"self",
")",
":",
"r",
"=",
"self",
".",
"_h",
".",
"_http_resource",
"(",
"method",
"=",
"'DELETE'",
",",
"resource",
"=",
"(",
"'user'",
",",
"'keys'",
")",
",",
")",
"return",
"r",
".",
"ok"
] |
Removes all SSH keys from a user's system.
|
[
"Removes",
"all",
"SSH",
"keys",
"from",
"a",
"user",
"s",
"system",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/structures.py#L108-L116
|
11,818
|
heroku/heroku.py
|
heroku/api.py
|
HerokuCore.authenticate
|
def authenticate(self, api_key):
"""Logs user into Heroku with given api_key."""
self._api_key = api_key
# Attach auth to session.
self._session.auth = ('', self._api_key)
return self._verify_api_key()
|
python
|
def authenticate(self, api_key):
"""Logs user into Heroku with given api_key."""
self._api_key = api_key
# Attach auth to session.
self._session.auth = ('', self._api_key)
return self._verify_api_key()
|
[
"def",
"authenticate",
"(",
"self",
",",
"api_key",
")",
":",
"self",
".",
"_api_key",
"=",
"api_key",
"# Attach auth to session.",
"self",
".",
"_session",
".",
"auth",
"=",
"(",
"''",
",",
"self",
".",
"_api_key",
")",
"return",
"self",
".",
"_verify_api_key",
"(",
")"
] |
Logs user into Heroku with given api_key.
|
[
"Logs",
"user",
"into",
"Heroku",
"with",
"given",
"api_key",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/api.py#L40-L47
|
11,819
|
heroku/heroku.py
|
heroku/api.py
|
HerokuCore._get_resource
|
def _get_resource(self, resource, obj, params=None, **kwargs):
"""Returns a mapped object from an HTTP resource."""
r = self._http_resource('GET', resource, params=params)
item = self._resource_deserialize(r.content.decode("utf-8"))
return obj.new_from_dict(item, h=self, **kwargs)
|
python
|
def _get_resource(self, resource, obj, params=None, **kwargs):
"""Returns a mapped object from an HTTP resource."""
r = self._http_resource('GET', resource, params=params)
item = self._resource_deserialize(r.content.decode("utf-8"))
return obj.new_from_dict(item, h=self, **kwargs)
|
[
"def",
"_get_resource",
"(",
"self",
",",
"resource",
",",
"obj",
",",
"params",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"r",
"=",
"self",
".",
"_http_resource",
"(",
"'GET'",
",",
"resource",
",",
"params",
"=",
"params",
")",
"item",
"=",
"self",
".",
"_resource_deserialize",
"(",
"r",
".",
"content",
".",
"decode",
"(",
"\"utf-8\"",
")",
")",
"return",
"obj",
".",
"new_from_dict",
"(",
"item",
",",
"h",
"=",
"self",
",",
"*",
"*",
"kwargs",
")"
] |
Returns a mapped object from an HTTP resource.
|
[
"Returns",
"a",
"mapped",
"object",
"from",
"an",
"HTTP",
"resource",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/api.py#L110-L115
|
11,820
|
heroku/heroku.py
|
heroku/api.py
|
HerokuCore._get_resources
|
def _get_resources(self, resource, obj, params=None, map=None, **kwargs):
"""Returns a list of mapped objects from an HTTP resource."""
r = self._http_resource('GET', resource, params=params)
d_items = self._resource_deserialize(r.content.decode("utf-8"))
items = [obj.new_from_dict(item, h=self, **kwargs) for item in d_items]
if map is None:
map = KeyedListResource
list_resource = map(items=items)
list_resource._h = self
list_resource._obj = obj
list_resource._kwargs = kwargs
return list_resource
|
python
|
def _get_resources(self, resource, obj, params=None, map=None, **kwargs):
"""Returns a list of mapped objects from an HTTP resource."""
r = self._http_resource('GET', resource, params=params)
d_items = self._resource_deserialize(r.content.decode("utf-8"))
items = [obj.new_from_dict(item, h=self, **kwargs) for item in d_items]
if map is None:
map = KeyedListResource
list_resource = map(items=items)
list_resource._h = self
list_resource._obj = obj
list_resource._kwargs = kwargs
return list_resource
|
[
"def",
"_get_resources",
"(",
"self",
",",
"resource",
",",
"obj",
",",
"params",
"=",
"None",
",",
"map",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"r",
"=",
"self",
".",
"_http_resource",
"(",
"'GET'",
",",
"resource",
",",
"params",
"=",
"params",
")",
"d_items",
"=",
"self",
".",
"_resource_deserialize",
"(",
"r",
".",
"content",
".",
"decode",
"(",
"\"utf-8\"",
")",
")",
"items",
"=",
"[",
"obj",
".",
"new_from_dict",
"(",
"item",
",",
"h",
"=",
"self",
",",
"*",
"*",
"kwargs",
")",
"for",
"item",
"in",
"d_items",
"]",
"if",
"map",
"is",
"None",
":",
"map",
"=",
"KeyedListResource",
"list_resource",
"=",
"map",
"(",
"items",
"=",
"items",
")",
"list_resource",
".",
"_h",
"=",
"self",
"list_resource",
".",
"_obj",
"=",
"obj",
"list_resource",
".",
"_kwargs",
"=",
"kwargs",
"return",
"list_resource"
] |
Returns a list of mapped objects from an HTTP resource.
|
[
"Returns",
"a",
"list",
"of",
"mapped",
"objects",
"from",
"an",
"HTTP",
"resource",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/api.py#L117-L132
|
11,821
|
heroku/heroku.py
|
heroku/core.py
|
from_key
|
def from_key(api_key, **kwargs):
"""Returns an authenticated Heroku instance, via API Key."""
h = Heroku(**kwargs)
# Login.
h.authenticate(api_key)
return h
|
python
|
def from_key(api_key, **kwargs):
"""Returns an authenticated Heroku instance, via API Key."""
h = Heroku(**kwargs)
# Login.
h.authenticate(api_key)
return h
|
[
"def",
"from_key",
"(",
"api_key",
",",
"*",
"*",
"kwargs",
")",
":",
"h",
"=",
"Heroku",
"(",
"*",
"*",
"kwargs",
")",
"# Login.",
"h",
".",
"authenticate",
"(",
"api_key",
")",
"return",
"h"
] |
Returns an authenticated Heroku instance, via API Key.
|
[
"Returns",
"an",
"authenticated",
"Heroku",
"instance",
"via",
"API",
"Key",
"."
] |
cadc0a074896cf29c65a457c5c5bdb2069470af0
|
https://github.com/heroku/heroku.py/blob/cadc0a074896cf29c65a457c5c5bdb2069470af0/heroku/core.py#L12-L20
|
11,822
|
pyviz/param
|
param/version.py
|
OldDeprecatedVersion.abbrev
|
def abbrev(self,dev_suffix=""):
"""
Abbreviated string representation, optionally declaring whether it is
a development version.
"""
return '.'.join(str(el) for el in self.release) + \
(dev_suffix if self.commit_count > 0 or self.dirty else "")
|
python
|
def abbrev(self,dev_suffix=""):
"""
Abbreviated string representation, optionally declaring whether it is
a development version.
"""
return '.'.join(str(el) for el in self.release) + \
(dev_suffix if self.commit_count > 0 or self.dirty else "")
|
[
"def",
"abbrev",
"(",
"self",
",",
"dev_suffix",
"=",
"\"\"",
")",
":",
"return",
"'.'",
".",
"join",
"(",
"str",
"(",
"el",
")",
"for",
"el",
"in",
"self",
".",
"release",
")",
"+",
"(",
"dev_suffix",
"if",
"self",
".",
"commit_count",
">",
"0",
"or",
"self",
".",
"dirty",
"else",
"\"\"",
")"
] |
Abbreviated string representation, optionally declaring whether it is
a development version.
|
[
"Abbreviated",
"string",
"representation",
"optionally",
"declaring",
"whether",
"it",
"is",
"a",
"development",
"version",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/version.py#L704-L710
|
11,823
|
pyviz/param
|
param/version.py
|
OldDeprecatedVersion.verify
|
def verify(self, string_version=None):
"""
Check that the version information is consistent with the VCS
before doing a release. If supplied with a string version,
this is also checked against the current version. Should be
called from setup.py with the declared package version before
releasing to PyPI.
"""
if string_version and string_version != str(self):
raise Exception("Supplied string version does not match current version.")
if self.dirty:
raise Exception("Current working directory is dirty.")
if self.release != self.expected_release:
raise Exception("Declared release does not match current release tag.")
if self.commit_count !=0:
raise Exception("Please update the VCS version tag before release.")
if self._expected_commit not in [None, "$Format:%h$"]:
raise Exception("Declared release does not match the VCS version tag")
|
python
|
def verify(self, string_version=None):
"""
Check that the version information is consistent with the VCS
before doing a release. If supplied with a string version,
this is also checked against the current version. Should be
called from setup.py with the declared package version before
releasing to PyPI.
"""
if string_version and string_version != str(self):
raise Exception("Supplied string version does not match current version.")
if self.dirty:
raise Exception("Current working directory is dirty.")
if self.release != self.expected_release:
raise Exception("Declared release does not match current release tag.")
if self.commit_count !=0:
raise Exception("Please update the VCS version tag before release.")
if self._expected_commit not in [None, "$Format:%h$"]:
raise Exception("Declared release does not match the VCS version tag")
|
[
"def",
"verify",
"(",
"self",
",",
"string_version",
"=",
"None",
")",
":",
"if",
"string_version",
"and",
"string_version",
"!=",
"str",
"(",
"self",
")",
":",
"raise",
"Exception",
"(",
"\"Supplied string version does not match current version.\"",
")",
"if",
"self",
".",
"dirty",
":",
"raise",
"Exception",
"(",
"\"Current working directory is dirty.\"",
")",
"if",
"self",
".",
"release",
"!=",
"self",
".",
"expected_release",
":",
"raise",
"Exception",
"(",
"\"Declared release does not match current release tag.\"",
")",
"if",
"self",
".",
"commit_count",
"!=",
"0",
":",
"raise",
"Exception",
"(",
"\"Please update the VCS version tag before release.\"",
")",
"if",
"self",
".",
"_expected_commit",
"not",
"in",
"[",
"None",
",",
"\"$Format:%h$\"",
"]",
":",
"raise",
"Exception",
"(",
"\"Declared release does not match the VCS version tag\"",
")"
] |
Check that the version information is consistent with the VCS
before doing a release. If supplied with a string version,
this is also checked against the current version. Should be
called from setup.py with the declared package version before
releasing to PyPI.
|
[
"Check",
"that",
"the",
"version",
"information",
"is",
"consistent",
"with",
"the",
"VCS",
"before",
"doing",
"a",
"release",
".",
"If",
"supplied",
"with",
"a",
"string",
"version",
"this",
"is",
"also",
"checked",
"against",
"the",
"current",
"version",
".",
"Should",
"be",
"called",
"from",
"setup",
".",
"py",
"with",
"the",
"declared",
"package",
"version",
"before",
"releasing",
"to",
"PyPI",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/version.py#L743-L764
|
11,824
|
pyviz/param
|
numbergen/__init__.py
|
TimeAware._check_time_fn
|
def _check_time_fn(self, time_instance=False):
"""
If time_fn is the global time function supplied by
param.Dynamic.time_fn, make sure Dynamic parameters are using
this time function to control their behaviour.
If time_instance is True, time_fn must be a param.Time instance.
"""
if time_instance and not isinstance(self.time_fn, param.Time):
raise AssertionError("%s requires a Time object"
% self.__class__.__name__)
if self.time_dependent:
global_timefn = self.time_fn is param.Dynamic.time_fn
if global_timefn and not param.Dynamic.time_dependent:
raise AssertionError("Cannot use Dynamic.time_fn as"
" parameters are ignoring time.")
|
python
|
def _check_time_fn(self, time_instance=False):
"""
If time_fn is the global time function supplied by
param.Dynamic.time_fn, make sure Dynamic parameters are using
this time function to control their behaviour.
If time_instance is True, time_fn must be a param.Time instance.
"""
if time_instance and not isinstance(self.time_fn, param.Time):
raise AssertionError("%s requires a Time object"
% self.__class__.__name__)
if self.time_dependent:
global_timefn = self.time_fn is param.Dynamic.time_fn
if global_timefn and not param.Dynamic.time_dependent:
raise AssertionError("Cannot use Dynamic.time_fn as"
" parameters are ignoring time.")
|
[
"def",
"_check_time_fn",
"(",
"self",
",",
"time_instance",
"=",
"False",
")",
":",
"if",
"time_instance",
"and",
"not",
"isinstance",
"(",
"self",
".",
"time_fn",
",",
"param",
".",
"Time",
")",
":",
"raise",
"AssertionError",
"(",
"\"%s requires a Time object\"",
"%",
"self",
".",
"__class__",
".",
"__name__",
")",
"if",
"self",
".",
"time_dependent",
":",
"global_timefn",
"=",
"self",
".",
"time_fn",
"is",
"param",
".",
"Dynamic",
".",
"time_fn",
"if",
"global_timefn",
"and",
"not",
"param",
".",
"Dynamic",
".",
"time_dependent",
":",
"raise",
"AssertionError",
"(",
"\"Cannot use Dynamic.time_fn as\"",
"\" parameters are ignoring time.\"",
")"
] |
If time_fn is the global time function supplied by
param.Dynamic.time_fn, make sure Dynamic parameters are using
this time function to control their behaviour.
If time_instance is True, time_fn must be a param.Time instance.
|
[
"If",
"time_fn",
"is",
"the",
"global",
"time",
"function",
"supplied",
"by",
"param",
".",
"Dynamic",
".",
"time_fn",
"make",
"sure",
"Dynamic",
"parameters",
"are",
"using",
"this",
"time",
"function",
"to",
"control",
"their",
"behaviour",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/numbergen/__init__.py#L48-L64
|
11,825
|
pyviz/param
|
numbergen/__init__.py
|
Hash._rational
|
def _rational(self, val):
"""Convert the given value to a rational, if necessary."""
I32 = 4294967296 # Maximum 32 bit unsigned int (i.e. 'I') value
if isinstance(val, int):
numer, denom = val, 1
elif isinstance(val, fractions.Fraction):
numer, denom = val.numerator, val.denominator
elif hasattr(val, 'numer'):
(numer, denom) = (int(val.numer()), int(val.denom()))
else:
param.main.param.warning("Casting type '%s' to Fraction.fraction"
% type(val).__name__)
frac = fractions.Fraction(str(val))
numer, denom = frac.numerator, frac.denominator
return numer % I32, denom % I32
|
python
|
def _rational(self, val):
"""Convert the given value to a rational, if necessary."""
I32 = 4294967296 # Maximum 32 bit unsigned int (i.e. 'I') value
if isinstance(val, int):
numer, denom = val, 1
elif isinstance(val, fractions.Fraction):
numer, denom = val.numerator, val.denominator
elif hasattr(val, 'numer'):
(numer, denom) = (int(val.numer()), int(val.denom()))
else:
param.main.param.warning("Casting type '%s' to Fraction.fraction"
% type(val).__name__)
frac = fractions.Fraction(str(val))
numer, denom = frac.numerator, frac.denominator
return numer % I32, denom % I32
|
[
"def",
"_rational",
"(",
"self",
",",
"val",
")",
":",
"I32",
"=",
"4294967296",
"# Maximum 32 bit unsigned int (i.e. 'I') value",
"if",
"isinstance",
"(",
"val",
",",
"int",
")",
":",
"numer",
",",
"denom",
"=",
"val",
",",
"1",
"elif",
"isinstance",
"(",
"val",
",",
"fractions",
".",
"Fraction",
")",
":",
"numer",
",",
"denom",
"=",
"val",
".",
"numerator",
",",
"val",
".",
"denominator",
"elif",
"hasattr",
"(",
"val",
",",
"'numer'",
")",
":",
"(",
"numer",
",",
"denom",
")",
"=",
"(",
"int",
"(",
"val",
".",
"numer",
"(",
")",
")",
",",
"int",
"(",
"val",
".",
"denom",
"(",
")",
")",
")",
"else",
":",
"param",
".",
"main",
".",
"param",
".",
"warning",
"(",
"\"Casting type '%s' to Fraction.fraction\"",
"%",
"type",
"(",
"val",
")",
".",
"__name__",
")",
"frac",
"=",
"fractions",
".",
"Fraction",
"(",
"str",
"(",
"val",
")",
")",
"numer",
",",
"denom",
"=",
"frac",
".",
"numerator",
",",
"frac",
".",
"denominator",
"return",
"numer",
"%",
"I32",
",",
"denom",
"%",
"I32"
] |
Convert the given value to a rational, if necessary.
|
[
"Convert",
"the",
"given",
"value",
"to",
"a",
"rational",
"if",
"necessary",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/numbergen/__init__.py#L200-L215
|
11,826
|
pyviz/param
|
numbergen/__init__.py
|
TimeAwareRandomState._initialize_random_state
|
def _initialize_random_state(self, seed=None, shared=True, name=None):
"""
Initialization method to be called in the constructor of
subclasses to initialize the random state correctly.
If seed is None, there is no control over the random stream
(no reproducibility of the stream).
If shared is True (and not time-dependent), the random state
is shared across all objects of the given class. This can be
overridden per object by creating new random state to assign
to the random_generator parameter.
"""
if seed is None: # Equivalent to an uncontrolled seed.
seed = random.Random().randint(0, 1000000)
suffix = ''
else:
suffix = str(seed)
# If time_dependent, independent state required: otherwise
# time-dependent seeding (via hash) will affect shared
# state. Note that if all objects have time_dependent=True
# shared random state is safe and more memory efficient.
if self.time_dependent or not shared:
self.random_generator = type(self.random_generator)(seed)
# Seed appropriately (if not shared)
if not shared:
self.random_generator.seed(seed)
if name is None:
self._verify_constrained_hash()
hash_name = name if name else self.name
if not shared: hash_name += suffix
self._hashfn = Hash(hash_name, input_count=2)
if self.time_dependent:
self._hash_and_seed()
|
python
|
def _initialize_random_state(self, seed=None, shared=True, name=None):
"""
Initialization method to be called in the constructor of
subclasses to initialize the random state correctly.
If seed is None, there is no control over the random stream
(no reproducibility of the stream).
If shared is True (and not time-dependent), the random state
is shared across all objects of the given class. This can be
overridden per object by creating new random state to assign
to the random_generator parameter.
"""
if seed is None: # Equivalent to an uncontrolled seed.
seed = random.Random().randint(0, 1000000)
suffix = ''
else:
suffix = str(seed)
# If time_dependent, independent state required: otherwise
# time-dependent seeding (via hash) will affect shared
# state. Note that if all objects have time_dependent=True
# shared random state is safe and more memory efficient.
if self.time_dependent or not shared:
self.random_generator = type(self.random_generator)(seed)
# Seed appropriately (if not shared)
if not shared:
self.random_generator.seed(seed)
if name is None:
self._verify_constrained_hash()
hash_name = name if name else self.name
if not shared: hash_name += suffix
self._hashfn = Hash(hash_name, input_count=2)
if self.time_dependent:
self._hash_and_seed()
|
[
"def",
"_initialize_random_state",
"(",
"self",
",",
"seed",
"=",
"None",
",",
"shared",
"=",
"True",
",",
"name",
"=",
"None",
")",
":",
"if",
"seed",
"is",
"None",
":",
"# Equivalent to an uncontrolled seed.",
"seed",
"=",
"random",
".",
"Random",
"(",
")",
".",
"randint",
"(",
"0",
",",
"1000000",
")",
"suffix",
"=",
"''",
"else",
":",
"suffix",
"=",
"str",
"(",
"seed",
")",
"# If time_dependent, independent state required: otherwise",
"# time-dependent seeding (via hash) will affect shared",
"# state. Note that if all objects have time_dependent=True",
"# shared random state is safe and more memory efficient.",
"if",
"self",
".",
"time_dependent",
"or",
"not",
"shared",
":",
"self",
".",
"random_generator",
"=",
"type",
"(",
"self",
".",
"random_generator",
")",
"(",
"seed",
")",
"# Seed appropriately (if not shared)",
"if",
"not",
"shared",
":",
"self",
".",
"random_generator",
".",
"seed",
"(",
"seed",
")",
"if",
"name",
"is",
"None",
":",
"self",
".",
"_verify_constrained_hash",
"(",
")",
"hash_name",
"=",
"name",
"if",
"name",
"else",
"self",
".",
"name",
"if",
"not",
"shared",
":",
"hash_name",
"+=",
"suffix",
"self",
".",
"_hashfn",
"=",
"Hash",
"(",
"hash_name",
",",
"input_count",
"=",
"2",
")",
"if",
"self",
".",
"time_dependent",
":",
"self",
".",
"_hash_and_seed",
"(",
")"
] |
Initialization method to be called in the constructor of
subclasses to initialize the random state correctly.
If seed is None, there is no control over the random stream
(no reproducibility of the stream).
If shared is True (and not time-dependent), the random state
is shared across all objects of the given class. This can be
overridden per object by creating new random state to assign
to the random_generator parameter.
|
[
"Initialization",
"method",
"to",
"be",
"called",
"in",
"the",
"constructor",
"of",
"subclasses",
"to",
"initialize",
"the",
"random",
"state",
"correctly",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/numbergen/__init__.py#L300-L338
|
11,827
|
pyviz/param
|
numbergen/__init__.py
|
TimeAwareRandomState._verify_constrained_hash
|
def _verify_constrained_hash(self):
"""
Warn if the object name is not explicitly set.
"""
changed_params = dict(self.param.get_param_values(onlychanged=True))
if self.time_dependent and ('name' not in changed_params):
self.param.warning("Default object name used to set the seed: "
"random values conditional on object instantiation order.")
|
python
|
def _verify_constrained_hash(self):
"""
Warn if the object name is not explicitly set.
"""
changed_params = dict(self.param.get_param_values(onlychanged=True))
if self.time_dependent and ('name' not in changed_params):
self.param.warning("Default object name used to set the seed: "
"random values conditional on object instantiation order.")
|
[
"def",
"_verify_constrained_hash",
"(",
"self",
")",
":",
"changed_params",
"=",
"dict",
"(",
"self",
".",
"param",
".",
"get_param_values",
"(",
"onlychanged",
"=",
"True",
")",
")",
"if",
"self",
".",
"time_dependent",
"and",
"(",
"'name'",
"not",
"in",
"changed_params",
")",
":",
"self",
".",
"param",
".",
"warning",
"(",
"\"Default object name used to set the seed: \"",
"\"random values conditional on object instantiation order.\"",
")"
] |
Warn if the object name is not explicitly set.
|
[
"Warn",
"if",
"the",
"object",
"name",
"is",
"not",
"explicitly",
"set",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/numbergen/__init__.py#L341-L348
|
11,828
|
pyviz/param
|
setup.py
|
get_setup_version
|
def get_setup_version(reponame):
"""Use autover to get up to date version."""
# importing self into setup.py is unorthodox, but param has no
# required dependencies outside of python
from param.version import Version
return Version.setup_version(os.path.dirname(__file__),reponame,archive_commit="$Format:%h$")
|
python
|
def get_setup_version(reponame):
"""Use autover to get up to date version."""
# importing self into setup.py is unorthodox, but param has no
# required dependencies outside of python
from param.version import Version
return Version.setup_version(os.path.dirname(__file__),reponame,archive_commit="$Format:%h$")
|
[
"def",
"get_setup_version",
"(",
"reponame",
")",
":",
"# importing self into setup.py is unorthodox, but param has no",
"# required dependencies outside of python",
"from",
"param",
".",
"version",
"import",
"Version",
"return",
"Version",
".",
"setup_version",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"__file__",
")",
",",
"reponame",
",",
"archive_commit",
"=",
"\"$Format:%h$\"",
")"
] |
Use autover to get up to date version.
|
[
"Use",
"autover",
"to",
"get",
"up",
"to",
"date",
"version",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/setup.py#L8-L13
|
11,829
|
pyviz/param
|
param/ipython.py
|
ParamPager.get_param_info
|
def get_param_info(self, obj, include_super=True):
"""
Get the parameter dictionary, the list of modifed parameters
and the dictionary or parameter values. If include_super is
True, parameters are also collected from the super classes.
"""
params = dict(obj.param.objects('existing'))
if isinstance(obj,type):
changed = []
val_dict = dict((k,p.default) for (k,p) in params.items())
self_class = obj
else:
changed = [name for (name,_) in obj.param.get_param_values(onlychanged=True)]
val_dict = dict(obj.param.get_param_values())
self_class = obj.__class__
if not include_super:
params = dict((k,v) for (k,v) in params.items()
if k in self_class.__dict__)
params.pop('name') # Already displayed in the title.
return (params, val_dict, changed)
|
python
|
def get_param_info(self, obj, include_super=True):
"""
Get the parameter dictionary, the list of modifed parameters
and the dictionary or parameter values. If include_super is
True, parameters are also collected from the super classes.
"""
params = dict(obj.param.objects('existing'))
if isinstance(obj,type):
changed = []
val_dict = dict((k,p.default) for (k,p) in params.items())
self_class = obj
else:
changed = [name for (name,_) in obj.param.get_param_values(onlychanged=True)]
val_dict = dict(obj.param.get_param_values())
self_class = obj.__class__
if not include_super:
params = dict((k,v) for (k,v) in params.items()
if k in self_class.__dict__)
params.pop('name') # Already displayed in the title.
return (params, val_dict, changed)
|
[
"def",
"get_param_info",
"(",
"self",
",",
"obj",
",",
"include_super",
"=",
"True",
")",
":",
"params",
"=",
"dict",
"(",
"obj",
".",
"param",
".",
"objects",
"(",
"'existing'",
")",
")",
"if",
"isinstance",
"(",
"obj",
",",
"type",
")",
":",
"changed",
"=",
"[",
"]",
"val_dict",
"=",
"dict",
"(",
"(",
"k",
",",
"p",
".",
"default",
")",
"for",
"(",
"k",
",",
"p",
")",
"in",
"params",
".",
"items",
"(",
")",
")",
"self_class",
"=",
"obj",
"else",
":",
"changed",
"=",
"[",
"name",
"for",
"(",
"name",
",",
"_",
")",
"in",
"obj",
".",
"param",
".",
"get_param_values",
"(",
"onlychanged",
"=",
"True",
")",
"]",
"val_dict",
"=",
"dict",
"(",
"obj",
".",
"param",
".",
"get_param_values",
"(",
")",
")",
"self_class",
"=",
"obj",
".",
"__class__",
"if",
"not",
"include_super",
":",
"params",
"=",
"dict",
"(",
"(",
"k",
",",
"v",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"params",
".",
"items",
"(",
")",
"if",
"k",
"in",
"self_class",
".",
"__dict__",
")",
"params",
".",
"pop",
"(",
"'name'",
")",
"# Already displayed in the title.",
"return",
"(",
"params",
",",
"val_dict",
",",
"changed",
")"
] |
Get the parameter dictionary, the list of modifed parameters
and the dictionary or parameter values. If include_super is
True, parameters are also collected from the super classes.
|
[
"Get",
"the",
"parameter",
"dictionary",
"the",
"list",
"of",
"modifed",
"parameters",
"and",
"the",
"dictionary",
"or",
"parameter",
"values",
".",
"If",
"include_super",
"is",
"True",
"parameters",
"are",
"also",
"collected",
"from",
"the",
"super",
"classes",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/ipython.py#L55-L77
|
11,830
|
pyviz/param
|
param/ipython.py
|
ParamPager._build_table
|
def _build_table(self, info, order, max_col_len=40, only_changed=False):
"""
Collect the information about parameters needed to build a
properly formatted table and then tabulate it.
"""
info_dict, bounds_dict = {}, {}
(params, val_dict, changed) = info
col_widths = dict((k,0) for k in order)
for name, p in params.items():
if only_changed and not (name in changed):
continue
constant = 'C' if p.constant else 'V'
readonly = 'RO' if p.readonly else 'RW'
allow_None = ' AN' if hasattr(p, 'allow_None') and p.allow_None else ''
mode = '%s %s%s' % (constant, readonly, allow_None)
info_dict[name] = {'name': name, 'type':p.__class__.__name__,
'mode':mode}
if hasattr(p, 'bounds'):
lbound, ubound = (None,None) if p.bounds is None else p.bounds
mark_lbound, mark_ubound = False, False
# Use soft_bounds when bounds not defined.
if hasattr(p, 'get_soft_bounds'):
soft_lbound, soft_ubound = p.get_soft_bounds()
if lbound is None and soft_lbound is not None:
lbound = soft_lbound
mark_lbound = True
if ubound is None and soft_ubound is not None:
ubound = soft_ubound
mark_ubound = True
if (lbound, ubound) != (None,None):
bounds_dict[name] = (mark_lbound, mark_ubound)
info_dict[name]['bounds'] = '(%s, %s)' % (lbound, ubound)
value = repr(val_dict[name])
if len(value) > (max_col_len - 3):
value = value[:max_col_len-3] + '...'
info_dict[name]['value'] = value
for col in info_dict[name]:
max_width = max([col_widths[col], len(info_dict[name][col])])
col_widths[col] = max_width
return self._tabulate(info_dict, col_widths, changed, order, bounds_dict)
|
python
|
def _build_table(self, info, order, max_col_len=40, only_changed=False):
"""
Collect the information about parameters needed to build a
properly formatted table and then tabulate it.
"""
info_dict, bounds_dict = {}, {}
(params, val_dict, changed) = info
col_widths = dict((k,0) for k in order)
for name, p in params.items():
if only_changed and not (name in changed):
continue
constant = 'C' if p.constant else 'V'
readonly = 'RO' if p.readonly else 'RW'
allow_None = ' AN' if hasattr(p, 'allow_None') and p.allow_None else ''
mode = '%s %s%s' % (constant, readonly, allow_None)
info_dict[name] = {'name': name, 'type':p.__class__.__name__,
'mode':mode}
if hasattr(p, 'bounds'):
lbound, ubound = (None,None) if p.bounds is None else p.bounds
mark_lbound, mark_ubound = False, False
# Use soft_bounds when bounds not defined.
if hasattr(p, 'get_soft_bounds'):
soft_lbound, soft_ubound = p.get_soft_bounds()
if lbound is None and soft_lbound is not None:
lbound = soft_lbound
mark_lbound = True
if ubound is None and soft_ubound is not None:
ubound = soft_ubound
mark_ubound = True
if (lbound, ubound) != (None,None):
bounds_dict[name] = (mark_lbound, mark_ubound)
info_dict[name]['bounds'] = '(%s, %s)' % (lbound, ubound)
value = repr(val_dict[name])
if len(value) > (max_col_len - 3):
value = value[:max_col_len-3] + '...'
info_dict[name]['value'] = value
for col in info_dict[name]:
max_width = max([col_widths[col], len(info_dict[name][col])])
col_widths[col] = max_width
return self._tabulate(info_dict, col_widths, changed, order, bounds_dict)
|
[
"def",
"_build_table",
"(",
"self",
",",
"info",
",",
"order",
",",
"max_col_len",
"=",
"40",
",",
"only_changed",
"=",
"False",
")",
":",
"info_dict",
",",
"bounds_dict",
"=",
"{",
"}",
",",
"{",
"}",
"(",
"params",
",",
"val_dict",
",",
"changed",
")",
"=",
"info",
"col_widths",
"=",
"dict",
"(",
"(",
"k",
",",
"0",
")",
"for",
"k",
"in",
"order",
")",
"for",
"name",
",",
"p",
"in",
"params",
".",
"items",
"(",
")",
":",
"if",
"only_changed",
"and",
"not",
"(",
"name",
"in",
"changed",
")",
":",
"continue",
"constant",
"=",
"'C'",
"if",
"p",
".",
"constant",
"else",
"'V'",
"readonly",
"=",
"'RO'",
"if",
"p",
".",
"readonly",
"else",
"'RW'",
"allow_None",
"=",
"' AN'",
"if",
"hasattr",
"(",
"p",
",",
"'allow_None'",
")",
"and",
"p",
".",
"allow_None",
"else",
"''",
"mode",
"=",
"'%s %s%s'",
"%",
"(",
"constant",
",",
"readonly",
",",
"allow_None",
")",
"info_dict",
"[",
"name",
"]",
"=",
"{",
"'name'",
":",
"name",
",",
"'type'",
":",
"p",
".",
"__class__",
".",
"__name__",
",",
"'mode'",
":",
"mode",
"}",
"if",
"hasattr",
"(",
"p",
",",
"'bounds'",
")",
":",
"lbound",
",",
"ubound",
"=",
"(",
"None",
",",
"None",
")",
"if",
"p",
".",
"bounds",
"is",
"None",
"else",
"p",
".",
"bounds",
"mark_lbound",
",",
"mark_ubound",
"=",
"False",
",",
"False",
"# Use soft_bounds when bounds not defined.",
"if",
"hasattr",
"(",
"p",
",",
"'get_soft_bounds'",
")",
":",
"soft_lbound",
",",
"soft_ubound",
"=",
"p",
".",
"get_soft_bounds",
"(",
")",
"if",
"lbound",
"is",
"None",
"and",
"soft_lbound",
"is",
"not",
"None",
":",
"lbound",
"=",
"soft_lbound",
"mark_lbound",
"=",
"True",
"if",
"ubound",
"is",
"None",
"and",
"soft_ubound",
"is",
"not",
"None",
":",
"ubound",
"=",
"soft_ubound",
"mark_ubound",
"=",
"True",
"if",
"(",
"lbound",
",",
"ubound",
")",
"!=",
"(",
"None",
",",
"None",
")",
":",
"bounds_dict",
"[",
"name",
"]",
"=",
"(",
"mark_lbound",
",",
"mark_ubound",
")",
"info_dict",
"[",
"name",
"]",
"[",
"'bounds'",
"]",
"=",
"'(%s, %s)'",
"%",
"(",
"lbound",
",",
"ubound",
")",
"value",
"=",
"repr",
"(",
"val_dict",
"[",
"name",
"]",
")",
"if",
"len",
"(",
"value",
")",
">",
"(",
"max_col_len",
"-",
"3",
")",
":",
"value",
"=",
"value",
"[",
":",
"max_col_len",
"-",
"3",
"]",
"+",
"'...'",
"info_dict",
"[",
"name",
"]",
"[",
"'value'",
"]",
"=",
"value",
"for",
"col",
"in",
"info_dict",
"[",
"name",
"]",
":",
"max_width",
"=",
"max",
"(",
"[",
"col_widths",
"[",
"col",
"]",
",",
"len",
"(",
"info_dict",
"[",
"name",
"]",
"[",
"col",
"]",
")",
"]",
")",
"col_widths",
"[",
"col",
"]",
"=",
"max_width",
"return",
"self",
".",
"_tabulate",
"(",
"info_dict",
",",
"col_widths",
",",
"changed",
",",
"order",
",",
"bounds_dict",
")"
] |
Collect the information about parameters needed to build a
properly formatted table and then tabulate it.
|
[
"Collect",
"the",
"information",
"about",
"parameters",
"needed",
"to",
"build",
"a",
"properly",
"formatted",
"table",
"and",
"then",
"tabulate",
"it",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/ipython.py#L127-L176
|
11,831
|
pyviz/param
|
param/ipython.py
|
ParamPager._tabulate
|
def _tabulate(self, info_dict, col_widths, changed, order, bounds_dict):
"""
Returns the supplied information as a table suitable for
printing or paging.
info_dict: Dictionary of the parameters name, type and mode.
col_widths: Dictionary of column widths in characters
changed: List of parameters modified from their defaults.
order: The order of the table columns
bound_dict: Dictionary of appropriately formatted bounds
"""
contents, tail = [], []
column_set = set(k for row in info_dict.values() for k in row)
columns = [col for col in order if col in column_set]
title_row = []
# Generate the column headings
for i, col in enumerate(columns):
width = col_widths[col]+2
col = col.capitalize()
formatted = col.ljust(width) if i == 0 else col.center(width)
title_row.append(formatted)
contents.append(blue % ''.join(title_row)+"\n")
# Format the table rows
for row in sorted(info_dict):
row_list = []
info = info_dict[row]
for i,col in enumerate(columns):
width = col_widths[col]+2
val = info[col] if (col in info) else ''
formatted = val.ljust(width) if i==0 else val.center(width)
if col == 'bounds' and bounds_dict.get(row,False):
(mark_lbound, mark_ubound) = bounds_dict[row]
lval, uval = formatted.rsplit(',')
lspace, lstr = lval.rsplit('(')
ustr, uspace = uval.rsplit(')')
lbound = lspace + '('+(cyan % lstr) if mark_lbound else lval
ubound = (cyan % ustr)+')'+uspace if mark_ubound else uval
formatted = "%s,%s" % (lbound, ubound)
row_list.append(formatted)
row_text = ''.join(row_list)
if row in changed:
row_text = red % row_text
contents.append(row_text)
return '\n'.join(contents+tail)
|
python
|
def _tabulate(self, info_dict, col_widths, changed, order, bounds_dict):
"""
Returns the supplied information as a table suitable for
printing or paging.
info_dict: Dictionary of the parameters name, type and mode.
col_widths: Dictionary of column widths in characters
changed: List of parameters modified from their defaults.
order: The order of the table columns
bound_dict: Dictionary of appropriately formatted bounds
"""
contents, tail = [], []
column_set = set(k for row in info_dict.values() for k in row)
columns = [col for col in order if col in column_set]
title_row = []
# Generate the column headings
for i, col in enumerate(columns):
width = col_widths[col]+2
col = col.capitalize()
formatted = col.ljust(width) if i == 0 else col.center(width)
title_row.append(formatted)
contents.append(blue % ''.join(title_row)+"\n")
# Format the table rows
for row in sorted(info_dict):
row_list = []
info = info_dict[row]
for i,col in enumerate(columns):
width = col_widths[col]+2
val = info[col] if (col in info) else ''
formatted = val.ljust(width) if i==0 else val.center(width)
if col == 'bounds' and bounds_dict.get(row,False):
(mark_lbound, mark_ubound) = bounds_dict[row]
lval, uval = formatted.rsplit(',')
lspace, lstr = lval.rsplit('(')
ustr, uspace = uval.rsplit(')')
lbound = lspace + '('+(cyan % lstr) if mark_lbound else lval
ubound = (cyan % ustr)+')'+uspace if mark_ubound else uval
formatted = "%s,%s" % (lbound, ubound)
row_list.append(formatted)
row_text = ''.join(row_list)
if row in changed:
row_text = red % row_text
contents.append(row_text)
return '\n'.join(contents+tail)
|
[
"def",
"_tabulate",
"(",
"self",
",",
"info_dict",
",",
"col_widths",
",",
"changed",
",",
"order",
",",
"bounds_dict",
")",
":",
"contents",
",",
"tail",
"=",
"[",
"]",
",",
"[",
"]",
"column_set",
"=",
"set",
"(",
"k",
"for",
"row",
"in",
"info_dict",
".",
"values",
"(",
")",
"for",
"k",
"in",
"row",
")",
"columns",
"=",
"[",
"col",
"for",
"col",
"in",
"order",
"if",
"col",
"in",
"column_set",
"]",
"title_row",
"=",
"[",
"]",
"# Generate the column headings",
"for",
"i",
",",
"col",
"in",
"enumerate",
"(",
"columns",
")",
":",
"width",
"=",
"col_widths",
"[",
"col",
"]",
"+",
"2",
"col",
"=",
"col",
".",
"capitalize",
"(",
")",
"formatted",
"=",
"col",
".",
"ljust",
"(",
"width",
")",
"if",
"i",
"==",
"0",
"else",
"col",
".",
"center",
"(",
"width",
")",
"title_row",
".",
"append",
"(",
"formatted",
")",
"contents",
".",
"append",
"(",
"blue",
"%",
"''",
".",
"join",
"(",
"title_row",
")",
"+",
"\"\\n\"",
")",
"# Format the table rows",
"for",
"row",
"in",
"sorted",
"(",
"info_dict",
")",
":",
"row_list",
"=",
"[",
"]",
"info",
"=",
"info_dict",
"[",
"row",
"]",
"for",
"i",
",",
"col",
"in",
"enumerate",
"(",
"columns",
")",
":",
"width",
"=",
"col_widths",
"[",
"col",
"]",
"+",
"2",
"val",
"=",
"info",
"[",
"col",
"]",
"if",
"(",
"col",
"in",
"info",
")",
"else",
"''",
"formatted",
"=",
"val",
".",
"ljust",
"(",
"width",
")",
"if",
"i",
"==",
"0",
"else",
"val",
".",
"center",
"(",
"width",
")",
"if",
"col",
"==",
"'bounds'",
"and",
"bounds_dict",
".",
"get",
"(",
"row",
",",
"False",
")",
":",
"(",
"mark_lbound",
",",
"mark_ubound",
")",
"=",
"bounds_dict",
"[",
"row",
"]",
"lval",
",",
"uval",
"=",
"formatted",
".",
"rsplit",
"(",
"','",
")",
"lspace",
",",
"lstr",
"=",
"lval",
".",
"rsplit",
"(",
"'('",
")",
"ustr",
",",
"uspace",
"=",
"uval",
".",
"rsplit",
"(",
"')'",
")",
"lbound",
"=",
"lspace",
"+",
"'('",
"+",
"(",
"cyan",
"%",
"lstr",
")",
"if",
"mark_lbound",
"else",
"lval",
"ubound",
"=",
"(",
"cyan",
"%",
"ustr",
")",
"+",
"')'",
"+",
"uspace",
"if",
"mark_ubound",
"else",
"uval",
"formatted",
"=",
"\"%s,%s\"",
"%",
"(",
"lbound",
",",
"ubound",
")",
"row_list",
".",
"append",
"(",
"formatted",
")",
"row_text",
"=",
"''",
".",
"join",
"(",
"row_list",
")",
"if",
"row",
"in",
"changed",
":",
"row_text",
"=",
"red",
"%",
"row_text",
"contents",
".",
"append",
"(",
"row_text",
")",
"return",
"'\\n'",
".",
"join",
"(",
"contents",
"+",
"tail",
")"
] |
Returns the supplied information as a table suitable for
printing or paging.
info_dict: Dictionary of the parameters name, type and mode.
col_widths: Dictionary of column widths in characters
changed: List of parameters modified from their defaults.
order: The order of the table columns
bound_dict: Dictionary of appropriately formatted bounds
|
[
"Returns",
"the",
"supplied",
"information",
"as",
"a",
"table",
"suitable",
"for",
"printing",
"or",
"paging",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/ipython.py#L179-L229
|
11,832
|
pyviz/param
|
param/__init__.py
|
is_ordered_dict
|
def is_ordered_dict(d):
"""
Predicate checking for ordered dictionaries. OrderedDict is always
ordered, and vanilla Python dictionaries are ordered for Python 3.6+
"""
py3_ordered_dicts = (sys.version_info.major == 3) and (sys.version_info.minor >= 6)
vanilla_odicts = (sys.version_info.major > 3) or py3_ordered_dicts
return isinstance(d, (OrderedDict))or (vanilla_odicts and isinstance(d, dict))
|
python
|
def is_ordered_dict(d):
"""
Predicate checking for ordered dictionaries. OrderedDict is always
ordered, and vanilla Python dictionaries are ordered for Python 3.6+
"""
py3_ordered_dicts = (sys.version_info.major == 3) and (sys.version_info.minor >= 6)
vanilla_odicts = (sys.version_info.major > 3) or py3_ordered_dicts
return isinstance(d, (OrderedDict))or (vanilla_odicts and isinstance(d, dict))
|
[
"def",
"is_ordered_dict",
"(",
"d",
")",
":",
"py3_ordered_dicts",
"=",
"(",
"sys",
".",
"version_info",
".",
"major",
"==",
"3",
")",
"and",
"(",
"sys",
".",
"version_info",
".",
"minor",
">=",
"6",
")",
"vanilla_odicts",
"=",
"(",
"sys",
".",
"version_info",
".",
"major",
">",
"3",
")",
"or",
"py3_ordered_dicts",
"return",
"isinstance",
"(",
"d",
",",
"(",
"OrderedDict",
")",
")",
"or",
"(",
"vanilla_odicts",
"and",
"isinstance",
"(",
"d",
",",
"dict",
")",
")"
] |
Predicate checking for ordered dictionaries. OrderedDict is always
ordered, and vanilla Python dictionaries are ordered for Python 3.6+
|
[
"Predicate",
"checking",
"for",
"ordered",
"dictionaries",
".",
"OrderedDict",
"is",
"always",
"ordered",
"and",
"vanilla",
"Python",
"dictionaries",
"are",
"ordered",
"for",
"Python",
"3",
".",
"6",
"+"
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L91-L98
|
11,833
|
pyviz/param
|
param/__init__.py
|
named_objs
|
def named_objs(objlist, namesdict=None):
"""
Given a list of objects, returns a dictionary mapping from
string name for the object to the object itself. Accepts
an optional name,obj dictionary, which will override any other
name if that item is present in the dictionary.
"""
objs = OrderedDict()
if namesdict is not None:
objtoname = {hashable(v): k for k, v in namesdict.items()}
for obj in objlist:
if namesdict is not None and hashable(obj) in objtoname:
k = objtoname[hashable(obj)]
elif hasattr(obj, "name"):
k = obj.name
elif hasattr(obj, '__name__'):
k = obj.__name__
else:
k = as_unicode(obj)
objs[k] = obj
return objs
|
python
|
def named_objs(objlist, namesdict=None):
"""
Given a list of objects, returns a dictionary mapping from
string name for the object to the object itself. Accepts
an optional name,obj dictionary, which will override any other
name if that item is present in the dictionary.
"""
objs = OrderedDict()
if namesdict is not None:
objtoname = {hashable(v): k for k, v in namesdict.items()}
for obj in objlist:
if namesdict is not None and hashable(obj) in objtoname:
k = objtoname[hashable(obj)]
elif hasattr(obj, "name"):
k = obj.name
elif hasattr(obj, '__name__'):
k = obj.__name__
else:
k = as_unicode(obj)
objs[k] = obj
return objs
|
[
"def",
"named_objs",
"(",
"objlist",
",",
"namesdict",
"=",
"None",
")",
":",
"objs",
"=",
"OrderedDict",
"(",
")",
"if",
"namesdict",
"is",
"not",
"None",
":",
"objtoname",
"=",
"{",
"hashable",
"(",
"v",
")",
":",
"k",
"for",
"k",
",",
"v",
"in",
"namesdict",
".",
"items",
"(",
")",
"}",
"for",
"obj",
"in",
"objlist",
":",
"if",
"namesdict",
"is",
"not",
"None",
"and",
"hashable",
"(",
"obj",
")",
"in",
"objtoname",
":",
"k",
"=",
"objtoname",
"[",
"hashable",
"(",
"obj",
")",
"]",
"elif",
"hasattr",
"(",
"obj",
",",
"\"name\"",
")",
":",
"k",
"=",
"obj",
".",
"name",
"elif",
"hasattr",
"(",
"obj",
",",
"'__name__'",
")",
":",
"k",
"=",
"obj",
".",
"__name__",
"else",
":",
"k",
"=",
"as_unicode",
"(",
"obj",
")",
"objs",
"[",
"k",
"]",
"=",
"obj",
"return",
"objs"
] |
Given a list of objects, returns a dictionary mapping from
string name for the object to the object itself. Accepts
an optional name,obj dictionary, which will override any other
name if that item is present in the dictionary.
|
[
"Given",
"a",
"list",
"of",
"objects",
"returns",
"a",
"dictionary",
"mapping",
"from",
"string",
"name",
"for",
"the",
"object",
"to",
"the",
"object",
"itself",
".",
"Accepts",
"an",
"optional",
"name",
"obj",
"dictionary",
"which",
"will",
"override",
"any",
"other",
"name",
"if",
"that",
"item",
"is",
"present",
"in",
"the",
"dictionary",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L117-L139
|
11,834
|
pyviz/param
|
param/__init__.py
|
guess_param_types
|
def guess_param_types(**kwargs):
"""
Given a set of keyword literals, promote to the appropriate
parameter type based on some simple heuristics.
"""
params = {}
for k, v in kwargs.items():
kws = dict(default=v, constant=True)
if isinstance(v, Parameter):
params[k] = v
elif isinstance(v, dt_types):
params[k] = Date(**kws)
elif isinstance(v, bool):
params[k] = Boolean(**kws)
elif isinstance(v, int):
params[k] = Integer(**kws)
elif isinstance(v, float):
params[k] = Number(**kws)
elif isinstance(v, str):
params[k] = String(**kws)
elif isinstance(v, dict):
params[k] = Dict(**kws)
elif isinstance(v, tuple):
if all(_is_number(el) for el in v):
params[k] = NumericTuple(**kws)
elif all(isinstance(el. dt_types) for el in v) and len(v)==2:
params[k] = DateRange(**kws)
else:
params[k] = Tuple(**kws)
elif isinstance(v, list):
params[k] = List(**kws)
elif isinstance(v, np.ndarray):
params[k] = Array(**kws)
else:
from pandas import DataFrame as pdDFrame
from pandas import Series as pdSeries
if isinstance(v, pdDFrame):
params[k] = DataFrame(**kws)
elif isinstance(v, pdSeries):
params[k] = Series(**kws)
else:
params[k] = Parameter(**kws)
return params
|
python
|
def guess_param_types(**kwargs):
"""
Given a set of keyword literals, promote to the appropriate
parameter type based on some simple heuristics.
"""
params = {}
for k, v in kwargs.items():
kws = dict(default=v, constant=True)
if isinstance(v, Parameter):
params[k] = v
elif isinstance(v, dt_types):
params[k] = Date(**kws)
elif isinstance(v, bool):
params[k] = Boolean(**kws)
elif isinstance(v, int):
params[k] = Integer(**kws)
elif isinstance(v, float):
params[k] = Number(**kws)
elif isinstance(v, str):
params[k] = String(**kws)
elif isinstance(v, dict):
params[k] = Dict(**kws)
elif isinstance(v, tuple):
if all(_is_number(el) for el in v):
params[k] = NumericTuple(**kws)
elif all(isinstance(el. dt_types) for el in v) and len(v)==2:
params[k] = DateRange(**kws)
else:
params[k] = Tuple(**kws)
elif isinstance(v, list):
params[k] = List(**kws)
elif isinstance(v, np.ndarray):
params[k] = Array(**kws)
else:
from pandas import DataFrame as pdDFrame
from pandas import Series as pdSeries
if isinstance(v, pdDFrame):
params[k] = DataFrame(**kws)
elif isinstance(v, pdSeries):
params[k] = Series(**kws)
else:
params[k] = Parameter(**kws)
return params
|
[
"def",
"guess_param_types",
"(",
"*",
"*",
"kwargs",
")",
":",
"params",
"=",
"{",
"}",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"kws",
"=",
"dict",
"(",
"default",
"=",
"v",
",",
"constant",
"=",
"True",
")",
"if",
"isinstance",
"(",
"v",
",",
"Parameter",
")",
":",
"params",
"[",
"k",
"]",
"=",
"v",
"elif",
"isinstance",
"(",
"v",
",",
"dt_types",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Date",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"bool",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Boolean",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"int",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Integer",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"float",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Number",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"str",
")",
":",
"params",
"[",
"k",
"]",
"=",
"String",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"dict",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Dict",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"tuple",
")",
":",
"if",
"all",
"(",
"_is_number",
"(",
"el",
")",
"for",
"el",
"in",
"v",
")",
":",
"params",
"[",
"k",
"]",
"=",
"NumericTuple",
"(",
"*",
"*",
"kws",
")",
"elif",
"all",
"(",
"isinstance",
"(",
"el",
".",
"dt_types",
")",
"for",
"el",
"in",
"v",
")",
"and",
"len",
"(",
"v",
")",
"==",
"2",
":",
"params",
"[",
"k",
"]",
"=",
"DateRange",
"(",
"*",
"*",
"kws",
")",
"else",
":",
"params",
"[",
"k",
"]",
"=",
"Tuple",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"list",
")",
":",
"params",
"[",
"k",
"]",
"=",
"List",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"np",
".",
"ndarray",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Array",
"(",
"*",
"*",
"kws",
")",
"else",
":",
"from",
"pandas",
"import",
"DataFrame",
"as",
"pdDFrame",
"from",
"pandas",
"import",
"Series",
"as",
"pdSeries",
"if",
"isinstance",
"(",
"v",
",",
"pdDFrame",
")",
":",
"params",
"[",
"k",
"]",
"=",
"DataFrame",
"(",
"*",
"*",
"kws",
")",
"elif",
"isinstance",
"(",
"v",
",",
"pdSeries",
")",
":",
"params",
"[",
"k",
"]",
"=",
"Series",
"(",
"*",
"*",
"kws",
")",
"else",
":",
"params",
"[",
"k",
"]",
"=",
"Parameter",
"(",
"*",
"*",
"kws",
")",
"return",
"params"
] |
Given a set of keyword literals, promote to the appropriate
parameter type based on some simple heuristics.
|
[
"Given",
"a",
"set",
"of",
"keyword",
"literals",
"promote",
"to",
"the",
"appropriate",
"parameter",
"type",
"based",
"on",
"some",
"simple",
"heuristics",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L164-L208
|
11,835
|
pyviz/param
|
param/__init__.py
|
guess_bounds
|
def guess_bounds(params, **overrides):
"""
Given a dictionary of Parameter instances, return a corresponding
set of copies with the bounds appropriately set.
If given a set of override keywords, use those numeric tuple bounds.
"""
guessed = {}
for name, p in params.items():
new_param = copy.copy(p)
if isinstance(p, (Integer, Number)):
if name in overrides:
minv,maxv = overrides[name]
else:
minv, maxv, _ = _get_min_max_value(None, None, value=p.default)
new_param.bounds = (minv, maxv)
guessed[name] = new_param
return guessed
|
python
|
def guess_bounds(params, **overrides):
"""
Given a dictionary of Parameter instances, return a corresponding
set of copies with the bounds appropriately set.
If given a set of override keywords, use those numeric tuple bounds.
"""
guessed = {}
for name, p in params.items():
new_param = copy.copy(p)
if isinstance(p, (Integer, Number)):
if name in overrides:
minv,maxv = overrides[name]
else:
minv, maxv, _ = _get_min_max_value(None, None, value=p.default)
new_param.bounds = (minv, maxv)
guessed[name] = new_param
return guessed
|
[
"def",
"guess_bounds",
"(",
"params",
",",
"*",
"*",
"overrides",
")",
":",
"guessed",
"=",
"{",
"}",
"for",
"name",
",",
"p",
"in",
"params",
".",
"items",
"(",
")",
":",
"new_param",
"=",
"copy",
".",
"copy",
"(",
"p",
")",
"if",
"isinstance",
"(",
"p",
",",
"(",
"Integer",
",",
"Number",
")",
")",
":",
"if",
"name",
"in",
"overrides",
":",
"minv",
",",
"maxv",
"=",
"overrides",
"[",
"name",
"]",
"else",
":",
"minv",
",",
"maxv",
",",
"_",
"=",
"_get_min_max_value",
"(",
"None",
",",
"None",
",",
"value",
"=",
"p",
".",
"default",
")",
"new_param",
".",
"bounds",
"=",
"(",
"minv",
",",
"maxv",
")",
"guessed",
"[",
"name",
"]",
"=",
"new_param",
"return",
"guessed"
] |
Given a dictionary of Parameter instances, return a corresponding
set of copies with the bounds appropriately set.
If given a set of override keywords, use those numeric tuple bounds.
|
[
"Given",
"a",
"dictionary",
"of",
"Parameter",
"instances",
"return",
"a",
"corresponding",
"set",
"of",
"copies",
"with",
"the",
"bounds",
"appropriately",
"set",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L221-L239
|
11,836
|
pyviz/param
|
param/__init__.py
|
Dynamic._initialize_generator
|
def _initialize_generator(self,gen,obj=None):
"""
Add 'last time' and 'last value' attributes to the generator.
"""
# CEBALERT: use a dictionary to hold these things.
if hasattr(obj,"_Dynamic_time_fn"):
gen._Dynamic_time_fn = obj._Dynamic_time_fn
gen._Dynamic_last = None
# CEB: I'd use None for this, except can't compare a fixedpoint
# number with None (e.g. 1>None but FixedPoint(1)>None can't be done)
gen._Dynamic_time = -1
gen._saved_Dynamic_last = []
gen._saved_Dynamic_time = []
|
python
|
def _initialize_generator(self,gen,obj=None):
"""
Add 'last time' and 'last value' attributes to the generator.
"""
# CEBALERT: use a dictionary to hold these things.
if hasattr(obj,"_Dynamic_time_fn"):
gen._Dynamic_time_fn = obj._Dynamic_time_fn
gen._Dynamic_last = None
# CEB: I'd use None for this, except can't compare a fixedpoint
# number with None (e.g. 1>None but FixedPoint(1)>None can't be done)
gen._Dynamic_time = -1
gen._saved_Dynamic_last = []
gen._saved_Dynamic_time = []
|
[
"def",
"_initialize_generator",
"(",
"self",
",",
"gen",
",",
"obj",
"=",
"None",
")",
":",
"# CEBALERT: use a dictionary to hold these things.",
"if",
"hasattr",
"(",
"obj",
",",
"\"_Dynamic_time_fn\"",
")",
":",
"gen",
".",
"_Dynamic_time_fn",
"=",
"obj",
".",
"_Dynamic_time_fn",
"gen",
".",
"_Dynamic_last",
"=",
"None",
"# CEB: I'd use None for this, except can't compare a fixedpoint",
"# number with None (e.g. 1>None but FixedPoint(1)>None can't be done)",
"gen",
".",
"_Dynamic_time",
"=",
"-",
"1",
"gen",
".",
"_saved_Dynamic_last",
"=",
"[",
"]",
"gen",
".",
"_saved_Dynamic_time",
"=",
"[",
"]"
] |
Add 'last time' and 'last value' attributes to the generator.
|
[
"Add",
"last",
"time",
"and",
"last",
"value",
"attributes",
"to",
"the",
"generator",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L576-L590
|
11,837
|
pyviz/param
|
param/__init__.py
|
Dynamic._produce_value
|
def _produce_value(self,gen,force=False):
"""
Return a value from gen.
If there is no time_fn, then a new value will be returned
(i.e. gen will be asked to produce a new value).
If force is True, or the value of time_fn() is different from
what it was was last time produce_value was called, a new
value will be produced and returned. Otherwise, the last value
gen produced will be returned.
"""
if hasattr(gen,"_Dynamic_time_fn"):
time_fn = gen._Dynamic_time_fn
else:
time_fn = self.time_fn
if (time_fn is None) or (not self.time_dependent):
value = produce_value(gen)
gen._Dynamic_last = value
else:
time = time_fn()
if force or time!=gen._Dynamic_time:
value = produce_value(gen)
gen._Dynamic_last = value
gen._Dynamic_time = time
else:
value = gen._Dynamic_last
return value
|
python
|
def _produce_value(self,gen,force=False):
"""
Return a value from gen.
If there is no time_fn, then a new value will be returned
(i.e. gen will be asked to produce a new value).
If force is True, or the value of time_fn() is different from
what it was was last time produce_value was called, a new
value will be produced and returned. Otherwise, the last value
gen produced will be returned.
"""
if hasattr(gen,"_Dynamic_time_fn"):
time_fn = gen._Dynamic_time_fn
else:
time_fn = self.time_fn
if (time_fn is None) or (not self.time_dependent):
value = produce_value(gen)
gen._Dynamic_last = value
else:
time = time_fn()
if force or time!=gen._Dynamic_time:
value = produce_value(gen)
gen._Dynamic_last = value
gen._Dynamic_time = time
else:
value = gen._Dynamic_last
return value
|
[
"def",
"_produce_value",
"(",
"self",
",",
"gen",
",",
"force",
"=",
"False",
")",
":",
"if",
"hasattr",
"(",
"gen",
",",
"\"_Dynamic_time_fn\"",
")",
":",
"time_fn",
"=",
"gen",
".",
"_Dynamic_time_fn",
"else",
":",
"time_fn",
"=",
"self",
".",
"time_fn",
"if",
"(",
"time_fn",
"is",
"None",
")",
"or",
"(",
"not",
"self",
".",
"time_dependent",
")",
":",
"value",
"=",
"produce_value",
"(",
"gen",
")",
"gen",
".",
"_Dynamic_last",
"=",
"value",
"else",
":",
"time",
"=",
"time_fn",
"(",
")",
"if",
"force",
"or",
"time",
"!=",
"gen",
".",
"_Dynamic_time",
":",
"value",
"=",
"produce_value",
"(",
"gen",
")",
"gen",
".",
"_Dynamic_last",
"=",
"value",
"gen",
".",
"_Dynamic_time",
"=",
"time",
"else",
":",
"value",
"=",
"gen",
".",
"_Dynamic_last",
"return",
"value"
] |
Return a value from gen.
If there is no time_fn, then a new value will be returned
(i.e. gen will be asked to produce a new value).
If force is True, or the value of time_fn() is different from
what it was was last time produce_value was called, a new
value will be produced and returned. Otherwise, the last value
gen produced will be returned.
|
[
"Return",
"a",
"value",
"from",
"gen",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L623-L655
|
11,838
|
pyviz/param
|
param/__init__.py
|
Dynamic._inspect
|
def _inspect(self,obj,objtype=None):
"""Return the last generated value for this parameter."""
gen=super(Dynamic,self).__get__(obj,objtype)
if hasattr(gen,'_Dynamic_last'):
return gen._Dynamic_last
else:
return gen
|
python
|
def _inspect(self,obj,objtype=None):
"""Return the last generated value for this parameter."""
gen=super(Dynamic,self).__get__(obj,objtype)
if hasattr(gen,'_Dynamic_last'):
return gen._Dynamic_last
else:
return gen
|
[
"def",
"_inspect",
"(",
"self",
",",
"obj",
",",
"objtype",
"=",
"None",
")",
":",
"gen",
"=",
"super",
"(",
"Dynamic",
",",
"self",
")",
".",
"__get__",
"(",
"obj",
",",
"objtype",
")",
"if",
"hasattr",
"(",
"gen",
",",
"'_Dynamic_last'",
")",
":",
"return",
"gen",
".",
"_Dynamic_last",
"else",
":",
"return",
"gen"
] |
Return the last generated value for this parameter.
|
[
"Return",
"the",
"last",
"generated",
"value",
"for",
"this",
"parameter",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L666-L673
|
11,839
|
pyviz/param
|
param/__init__.py
|
Dynamic._force
|
def _force(self,obj,objtype=None):
"""Force a new value to be generated, and return it."""
gen=super(Dynamic,self).__get__(obj,objtype)
if hasattr(gen,'_Dynamic_last'):
return self._produce_value(gen,force=True)
else:
return gen
|
python
|
def _force(self,obj,objtype=None):
"""Force a new value to be generated, and return it."""
gen=super(Dynamic,self).__get__(obj,objtype)
if hasattr(gen,'_Dynamic_last'):
return self._produce_value(gen,force=True)
else:
return gen
|
[
"def",
"_force",
"(",
"self",
",",
"obj",
",",
"objtype",
"=",
"None",
")",
":",
"gen",
"=",
"super",
"(",
"Dynamic",
",",
"self",
")",
".",
"__get__",
"(",
"obj",
",",
"objtype",
")",
"if",
"hasattr",
"(",
"gen",
",",
"'_Dynamic_last'",
")",
":",
"return",
"self",
".",
"_produce_value",
"(",
"gen",
",",
"force",
"=",
"True",
")",
"else",
":",
"return",
"gen"
] |
Force a new value to be generated, and return it.
|
[
"Force",
"a",
"new",
"value",
"to",
"be",
"generated",
"and",
"return",
"it",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L676-L683
|
11,840
|
pyviz/param
|
param/__init__.py
|
Number.set_in_bounds
|
def set_in_bounds(self,obj,val):
"""
Set to the given value, but cropped to be within the legal bounds.
All objects are accepted, and no exceptions will be raised. See
crop_to_bounds for details on how cropping is done.
"""
if not callable(val):
bounded_val = self.crop_to_bounds(val)
else:
bounded_val = val
super(Number,self).__set__(obj,bounded_val)
|
python
|
def set_in_bounds(self,obj,val):
"""
Set to the given value, but cropped to be within the legal bounds.
All objects are accepted, and no exceptions will be raised. See
crop_to_bounds for details on how cropping is done.
"""
if not callable(val):
bounded_val = self.crop_to_bounds(val)
else:
bounded_val = val
super(Number,self).__set__(obj,bounded_val)
|
[
"def",
"set_in_bounds",
"(",
"self",
",",
"obj",
",",
"val",
")",
":",
"if",
"not",
"callable",
"(",
"val",
")",
":",
"bounded_val",
"=",
"self",
".",
"crop_to_bounds",
"(",
"val",
")",
"else",
":",
"bounded_val",
"=",
"val",
"super",
"(",
"Number",
",",
"self",
")",
".",
"__set__",
"(",
"obj",
",",
"bounded_val",
")"
] |
Set to the given value, but cropped to be within the legal bounds.
All objects are accepted, and no exceptions will be raised. See
crop_to_bounds for details on how cropping is done.
|
[
"Set",
"to",
"the",
"given",
"value",
"but",
"cropped",
"to",
"be",
"within",
"the",
"legal",
"bounds",
".",
"All",
"objects",
"are",
"accepted",
"and",
"no",
"exceptions",
"will",
"be",
"raised",
".",
"See",
"crop_to_bounds",
"for",
"details",
"on",
"how",
"cropping",
"is",
"done",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L786-L796
|
11,841
|
pyviz/param
|
param/__init__.py
|
Number.crop_to_bounds
|
def crop_to_bounds(self,val):
"""
Return the given value cropped to be within the hard bounds
for this parameter.
If a numeric value is passed in, check it is within the hard
bounds. If it is larger than the high bound, return the high
bound. If it's smaller, return the low bound. In either case, the
returned value could be None. If a non-numeric value is passed
in, set to be the default value (which could be None). In no
case is an exception raised; all values are accepted.
"""
# Currently, values outside the bounds are silently cropped to
# be inside the bounds; it may be appropriate to add a warning
# in such cases.
if _is_number(val):
if self.bounds is None:
return val
vmin, vmax = self.bounds
if vmin is not None:
if val < vmin:
return vmin
if vmax is not None:
if val > vmax:
return vmax
elif self.allow_None and val is None:
return val
else:
# non-numeric value sent in: reverts to default value
return self.default
return val
|
python
|
def crop_to_bounds(self,val):
"""
Return the given value cropped to be within the hard bounds
for this parameter.
If a numeric value is passed in, check it is within the hard
bounds. If it is larger than the high bound, return the high
bound. If it's smaller, return the low bound. In either case, the
returned value could be None. If a non-numeric value is passed
in, set to be the default value (which could be None). In no
case is an exception raised; all values are accepted.
"""
# Currently, values outside the bounds are silently cropped to
# be inside the bounds; it may be appropriate to add a warning
# in such cases.
if _is_number(val):
if self.bounds is None:
return val
vmin, vmax = self.bounds
if vmin is not None:
if val < vmin:
return vmin
if vmax is not None:
if val > vmax:
return vmax
elif self.allow_None and val is None:
return val
else:
# non-numeric value sent in: reverts to default value
return self.default
return val
|
[
"def",
"crop_to_bounds",
"(",
"self",
",",
"val",
")",
":",
"# Currently, values outside the bounds are silently cropped to",
"# be inside the bounds; it may be appropriate to add a warning",
"# in such cases.",
"if",
"_is_number",
"(",
"val",
")",
":",
"if",
"self",
".",
"bounds",
"is",
"None",
":",
"return",
"val",
"vmin",
",",
"vmax",
"=",
"self",
".",
"bounds",
"if",
"vmin",
"is",
"not",
"None",
":",
"if",
"val",
"<",
"vmin",
":",
"return",
"vmin",
"if",
"vmax",
"is",
"not",
"None",
":",
"if",
"val",
">",
"vmax",
":",
"return",
"vmax",
"elif",
"self",
".",
"allow_None",
"and",
"val",
"is",
"None",
":",
"return",
"val",
"else",
":",
"# non-numeric value sent in: reverts to default value",
"return",
"self",
".",
"default",
"return",
"val"
] |
Return the given value cropped to be within the hard bounds
for this parameter.
If a numeric value is passed in, check it is within the hard
bounds. If it is larger than the high bound, return the high
bound. If it's smaller, return the low bound. In either case, the
returned value could be None. If a non-numeric value is passed
in, set to be the default value (which could be None). In no
case is an exception raised; all values are accepted.
|
[
"Return",
"the",
"given",
"value",
"cropped",
"to",
"be",
"within",
"the",
"hard",
"bounds",
"for",
"this",
"parameter",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L801-L835
|
11,842
|
pyviz/param
|
param/__init__.py
|
ObjectSelector._validate
|
def _validate(self, val):
"""
val must be None or one of the objects in self.objects.
"""
if not self.check_on_set:
self._ensure_value_is_in_objects(val)
return
if not (val in self.objects or (self.allow_None and val is None)):
# CEBALERT: can be called before __init__ has called
# super's __init__, i.e. before attrib_name has been set.
try:
attrib_name = self.name
except AttributeError:
attrib_name = ""
items = []
limiter = ']'
length = 0
for item in self.objects:
string = str(item)
length += len(string)
if length < 200:
items.append(string)
else:
limiter = ', ...]'
break
items = '[' + ', '.join(items) + limiter
raise ValueError("%s not in Parameter %s's list of possible objects, "
"valid options include %s"%(val,attrib_name, items))
|
python
|
def _validate(self, val):
"""
val must be None or one of the objects in self.objects.
"""
if not self.check_on_set:
self._ensure_value_is_in_objects(val)
return
if not (val in self.objects or (self.allow_None and val is None)):
# CEBALERT: can be called before __init__ has called
# super's __init__, i.e. before attrib_name has been set.
try:
attrib_name = self.name
except AttributeError:
attrib_name = ""
items = []
limiter = ']'
length = 0
for item in self.objects:
string = str(item)
length += len(string)
if length < 200:
items.append(string)
else:
limiter = ', ...]'
break
items = '[' + ', '.join(items) + limiter
raise ValueError("%s not in Parameter %s's list of possible objects, "
"valid options include %s"%(val,attrib_name, items))
|
[
"def",
"_validate",
"(",
"self",
",",
"val",
")",
":",
"if",
"not",
"self",
".",
"check_on_set",
":",
"self",
".",
"_ensure_value_is_in_objects",
"(",
"val",
")",
"return",
"if",
"not",
"(",
"val",
"in",
"self",
".",
"objects",
"or",
"(",
"self",
".",
"allow_None",
"and",
"val",
"is",
"None",
")",
")",
":",
"# CEBALERT: can be called before __init__ has called",
"# super's __init__, i.e. before attrib_name has been set.",
"try",
":",
"attrib_name",
"=",
"self",
".",
"name",
"except",
"AttributeError",
":",
"attrib_name",
"=",
"\"\"",
"items",
"=",
"[",
"]",
"limiter",
"=",
"']'",
"length",
"=",
"0",
"for",
"item",
"in",
"self",
".",
"objects",
":",
"string",
"=",
"str",
"(",
"item",
")",
"length",
"+=",
"len",
"(",
"string",
")",
"if",
"length",
"<",
"200",
":",
"items",
".",
"append",
"(",
"string",
")",
"else",
":",
"limiter",
"=",
"', ...]'",
"break",
"items",
"=",
"'['",
"+",
"', '",
".",
"join",
"(",
"items",
")",
"+",
"limiter",
"raise",
"ValueError",
"(",
"\"%s not in Parameter %s's list of possible objects, \"",
"\"valid options include %s\"",
"%",
"(",
"val",
",",
"attrib_name",
",",
"items",
")",
")"
] |
val must be None or one of the objects in self.objects.
|
[
"val",
"must",
"be",
"None",
"or",
"one",
"of",
"the",
"objects",
"in",
"self",
".",
"objects",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1206-L1235
|
11,843
|
pyviz/param
|
param/__init__.py
|
ObjectSelector._ensure_value_is_in_objects
|
def _ensure_value_is_in_objects(self,val):
"""
Make sure that the provided value is present on the objects list.
Subclasses can override if they support multiple items on a list,
to check each item instead.
"""
if not (val in self.objects):
self.objects.append(val)
|
python
|
def _ensure_value_is_in_objects(self,val):
"""
Make sure that the provided value is present on the objects list.
Subclasses can override if they support multiple items on a list,
to check each item instead.
"""
if not (val in self.objects):
self.objects.append(val)
|
[
"def",
"_ensure_value_is_in_objects",
"(",
"self",
",",
"val",
")",
":",
"if",
"not",
"(",
"val",
"in",
"self",
".",
"objects",
")",
":",
"self",
".",
"objects",
".",
"append",
"(",
"val",
")"
] |
Make sure that the provided value is present on the objects list.
Subclasses can override if they support multiple items on a list,
to check each item instead.
|
[
"Make",
"sure",
"that",
"the",
"provided",
"value",
"is",
"present",
"on",
"the",
"objects",
"list",
".",
"Subclasses",
"can",
"override",
"if",
"they",
"support",
"multiple",
"items",
"on",
"a",
"list",
"to",
"check",
"each",
"item",
"instead",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1237-L1244
|
11,844
|
pyviz/param
|
param/__init__.py
|
ClassSelector._validate
|
def _validate(self,val):
"""val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False"""
if isinstance(self.class_, tuple):
class_name = ('(%s)' % ', '.join(cl.__name__ for cl in self.class_))
else:
class_name = self.class_.__name__
if self.is_instance:
if not (isinstance(val,self.class_)) and not (val is None and self.allow_None):
raise ValueError(
"Parameter '%s' value must be an instance of %s, not '%s'" %
(self.name, class_name, val))
else:
if not (val is None and self.allow_None) and not (issubclass(val,self.class_)):
raise ValueError(
"Parameter '%s' must be a subclass of %s, not '%s'" %
(val.__name__, class_name, val.__class__.__name__))
|
python
|
def _validate(self,val):
"""val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False"""
if isinstance(self.class_, tuple):
class_name = ('(%s)' % ', '.join(cl.__name__ for cl in self.class_))
else:
class_name = self.class_.__name__
if self.is_instance:
if not (isinstance(val,self.class_)) and not (val is None and self.allow_None):
raise ValueError(
"Parameter '%s' value must be an instance of %s, not '%s'" %
(self.name, class_name, val))
else:
if not (val is None and self.allow_None) and not (issubclass(val,self.class_)):
raise ValueError(
"Parameter '%s' must be a subclass of %s, not '%s'" %
(val.__name__, class_name, val.__class__.__name__))
|
[
"def",
"_validate",
"(",
"self",
",",
"val",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"class_",
",",
"tuple",
")",
":",
"class_name",
"=",
"(",
"'(%s)'",
"%",
"', '",
".",
"join",
"(",
"cl",
".",
"__name__",
"for",
"cl",
"in",
"self",
".",
"class_",
")",
")",
"else",
":",
"class_name",
"=",
"self",
".",
"class_",
".",
"__name__",
"if",
"self",
".",
"is_instance",
":",
"if",
"not",
"(",
"isinstance",
"(",
"val",
",",
"self",
".",
"class_",
")",
")",
"and",
"not",
"(",
"val",
"is",
"None",
"and",
"self",
".",
"allow_None",
")",
":",
"raise",
"ValueError",
"(",
"\"Parameter '%s' value must be an instance of %s, not '%s'\"",
"%",
"(",
"self",
".",
"name",
",",
"class_name",
",",
"val",
")",
")",
"else",
":",
"if",
"not",
"(",
"val",
"is",
"None",
"and",
"self",
".",
"allow_None",
")",
"and",
"not",
"(",
"issubclass",
"(",
"val",
",",
"self",
".",
"class_",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"Parameter '%s' must be a subclass of %s, not '%s'\"",
"%",
"(",
"val",
".",
"__name__",
",",
"class_name",
",",
"val",
".",
"__class__",
".",
"__name__",
")",
")"
] |
val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False
|
[
"val",
"must",
"be",
"None",
"an",
"instance",
"of",
"self",
".",
"class_",
"if",
"self",
".",
"is_instance",
"=",
"True",
"or",
"a",
"subclass",
"of",
"self_class",
"if",
"self",
".",
"is_instance",
"=",
"False"
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1303-L1318
|
11,845
|
pyviz/param
|
param/__init__.py
|
ClassSelector.get_range
|
def get_range(self):
"""
Return the possible types for this parameter's value.
(I.e. return {name: <class>} for all classes that are
concrete_descendents() of self.class_.)
Only classes from modules that have been imported are added
(see concrete_descendents()).
"""
classes = concrete_descendents(self.class_)
d=OrderedDict((name,class_) for name,class_ in classes.items())
if self.allow_None:
d['None']=None
return d
|
python
|
def get_range(self):
"""
Return the possible types for this parameter's value.
(I.e. return {name: <class>} for all classes that are
concrete_descendents() of self.class_.)
Only classes from modules that have been imported are added
(see concrete_descendents()).
"""
classes = concrete_descendents(self.class_)
d=OrderedDict((name,class_) for name,class_ in classes.items())
if self.allow_None:
d['None']=None
return d
|
[
"def",
"get_range",
"(",
"self",
")",
":",
"classes",
"=",
"concrete_descendents",
"(",
"self",
".",
"class_",
")",
"d",
"=",
"OrderedDict",
"(",
"(",
"name",
",",
"class_",
")",
"for",
"name",
",",
"class_",
"in",
"classes",
".",
"items",
"(",
")",
")",
"if",
"self",
".",
"allow_None",
":",
"d",
"[",
"'None'",
"]",
"=",
"None",
"return",
"d"
] |
Return the possible types for this parameter's value.
(I.e. return {name: <class>} for all classes that are
concrete_descendents() of self.class_.)
Only classes from modules that have been imported are added
(see concrete_descendents()).
|
[
"Return",
"the",
"possible",
"types",
"for",
"this",
"parameter",
"s",
"value",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1321-L1335
|
11,846
|
pyviz/param
|
param/__init__.py
|
List._validate
|
def _validate(self, val):
"""
Checks that the list is of the right length and has the right contents.
Otherwise, an exception is raised.
"""
if self.allow_None and val is None:
return
if not isinstance(val, list):
raise ValueError("List '%s' must be a list."%(self.name))
if self.bounds is not None:
min_length,max_length = self.bounds
l=len(val)
if min_length is not None and max_length is not None:
if not (min_length <= l <= max_length):
raise ValueError("%s: list length must be between %s and %s (inclusive)"%(self.name,min_length,max_length))
elif min_length is not None:
if not min_length <= l:
raise ValueError("%s: list length must be at least %s."%(self.name,min_length))
elif max_length is not None:
if not l <= max_length:
raise ValueError("%s: list length must be at most %s."%(self.name,max_length))
self._check_type(val)
|
python
|
def _validate(self, val):
"""
Checks that the list is of the right length and has the right contents.
Otherwise, an exception is raised.
"""
if self.allow_None and val is None:
return
if not isinstance(val, list):
raise ValueError("List '%s' must be a list."%(self.name))
if self.bounds is not None:
min_length,max_length = self.bounds
l=len(val)
if min_length is not None and max_length is not None:
if not (min_length <= l <= max_length):
raise ValueError("%s: list length must be between %s and %s (inclusive)"%(self.name,min_length,max_length))
elif min_length is not None:
if not min_length <= l:
raise ValueError("%s: list length must be at least %s."%(self.name,min_length))
elif max_length is not None:
if not l <= max_length:
raise ValueError("%s: list length must be at most %s."%(self.name,max_length))
self._check_type(val)
|
[
"def",
"_validate",
"(",
"self",
",",
"val",
")",
":",
"if",
"self",
".",
"allow_None",
"and",
"val",
"is",
"None",
":",
"return",
"if",
"not",
"isinstance",
"(",
"val",
",",
"list",
")",
":",
"raise",
"ValueError",
"(",
"\"List '%s' must be a list.\"",
"%",
"(",
"self",
".",
"name",
")",
")",
"if",
"self",
".",
"bounds",
"is",
"not",
"None",
":",
"min_length",
",",
"max_length",
"=",
"self",
".",
"bounds",
"l",
"=",
"len",
"(",
"val",
")",
"if",
"min_length",
"is",
"not",
"None",
"and",
"max_length",
"is",
"not",
"None",
":",
"if",
"not",
"(",
"min_length",
"<=",
"l",
"<=",
"max_length",
")",
":",
"raise",
"ValueError",
"(",
"\"%s: list length must be between %s and %s (inclusive)\"",
"%",
"(",
"self",
".",
"name",
",",
"min_length",
",",
"max_length",
")",
")",
"elif",
"min_length",
"is",
"not",
"None",
":",
"if",
"not",
"min_length",
"<=",
"l",
":",
"raise",
"ValueError",
"(",
"\"%s: list length must be at least %s.\"",
"%",
"(",
"self",
".",
"name",
",",
"min_length",
")",
")",
"elif",
"max_length",
"is",
"not",
"None",
":",
"if",
"not",
"l",
"<=",
"max_length",
":",
"raise",
"ValueError",
"(",
"\"%s: list length must be at most %s.\"",
"%",
"(",
"self",
".",
"name",
",",
"max_length",
")",
")",
"self",
".",
"_check_type",
"(",
"val",
")"
] |
Checks that the list is of the right length and has the right contents.
Otherwise, an exception is raised.
|
[
"Checks",
"that",
"the",
"list",
"is",
"of",
"the",
"right",
"length",
"and",
"has",
"the",
"right",
"contents",
".",
"Otherwise",
"an",
"exception",
"is",
"raised",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1357-L1381
|
11,847
|
pyviz/param
|
param/parameterized.py
|
logging_level
|
def logging_level(level):
"""
Temporarily modify param's logging level.
"""
level = level.upper()
levels = [DEBUG, INFO, WARNING, ERROR, CRITICAL, VERBOSE]
level_names = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'VERBOSE']
if level not in level_names:
raise Exception("Level %r not in %r" % (level, levels))
param_logger = get_logger()
logging_level = param_logger.getEffectiveLevel()
param_logger.setLevel(levels[level_names.index(level)])
try:
yield None
finally:
param_logger.setLevel(logging_level)
|
python
|
def logging_level(level):
"""
Temporarily modify param's logging level.
"""
level = level.upper()
levels = [DEBUG, INFO, WARNING, ERROR, CRITICAL, VERBOSE]
level_names = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'VERBOSE']
if level not in level_names:
raise Exception("Level %r not in %r" % (level, levels))
param_logger = get_logger()
logging_level = param_logger.getEffectiveLevel()
param_logger.setLevel(levels[level_names.index(level)])
try:
yield None
finally:
param_logger.setLevel(logging_level)
|
[
"def",
"logging_level",
"(",
"level",
")",
":",
"level",
"=",
"level",
".",
"upper",
"(",
")",
"levels",
"=",
"[",
"DEBUG",
",",
"INFO",
",",
"WARNING",
",",
"ERROR",
",",
"CRITICAL",
",",
"VERBOSE",
"]",
"level_names",
"=",
"[",
"'DEBUG'",
",",
"'INFO'",
",",
"'WARNING'",
",",
"'ERROR'",
",",
"'CRITICAL'",
",",
"'VERBOSE'",
"]",
"if",
"level",
"not",
"in",
"level_names",
":",
"raise",
"Exception",
"(",
"\"Level %r not in %r\"",
"%",
"(",
"level",
",",
"levels",
")",
")",
"param_logger",
"=",
"get_logger",
"(",
")",
"logging_level",
"=",
"param_logger",
".",
"getEffectiveLevel",
"(",
")",
"param_logger",
".",
"setLevel",
"(",
"levels",
"[",
"level_names",
".",
"index",
"(",
"level",
")",
"]",
")",
"try",
":",
"yield",
"None",
"finally",
":",
"param_logger",
".",
"setLevel",
"(",
"logging_level",
")"
] |
Temporarily modify param's logging level.
|
[
"Temporarily",
"modify",
"param",
"s",
"logging",
"level",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L69-L86
|
11,848
|
pyviz/param
|
param/parameterized.py
|
batch_watch
|
def batch_watch(parameterized, run=True):
"""
Context manager to batch watcher events on a parameterized object.
The context manager will queue any events triggered by setting a
parameter on the supplied parameterized object and dispatch them
all at once when the context manager exits. If run=False the
queued events are not dispatched and should be processed manually.
"""
BATCH_WATCH = parameterized.param._BATCH_WATCH
parameterized.param._BATCH_WATCH = True
try:
yield
finally:
parameterized.param._BATCH_WATCH = BATCH_WATCH
if run and not BATCH_WATCH:
parameterized.param._batch_call_watchers()
|
python
|
def batch_watch(parameterized, run=True):
"""
Context manager to batch watcher events on a parameterized object.
The context manager will queue any events triggered by setting a
parameter on the supplied parameterized object and dispatch them
all at once when the context manager exits. If run=False the
queued events are not dispatched and should be processed manually.
"""
BATCH_WATCH = parameterized.param._BATCH_WATCH
parameterized.param._BATCH_WATCH = True
try:
yield
finally:
parameterized.param._BATCH_WATCH = BATCH_WATCH
if run and not BATCH_WATCH:
parameterized.param._batch_call_watchers()
|
[
"def",
"batch_watch",
"(",
"parameterized",
",",
"run",
"=",
"True",
")",
":",
"BATCH_WATCH",
"=",
"parameterized",
".",
"param",
".",
"_BATCH_WATCH",
"parameterized",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"True",
"try",
":",
"yield",
"finally",
":",
"parameterized",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"BATCH_WATCH",
"if",
"run",
"and",
"not",
"BATCH_WATCH",
":",
"parameterized",
".",
"param",
".",
"_batch_call_watchers",
"(",
")"
] |
Context manager to batch watcher events on a parameterized object.
The context manager will queue any events triggered by setting a
parameter on the supplied parameterized object and dispatch them
all at once when the context manager exits. If run=False the
queued events are not dispatched and should be processed manually.
|
[
"Context",
"manager",
"to",
"batch",
"watcher",
"events",
"on",
"a",
"parameterized",
"object",
".",
"The",
"context",
"manager",
"will",
"queue",
"any",
"events",
"triggered",
"by",
"setting",
"a",
"parameter",
"on",
"the",
"supplied",
"parameterized",
"object",
"and",
"dispatch",
"them",
"all",
"at",
"once",
"when",
"the",
"context",
"manager",
"exits",
".",
"If",
"run",
"=",
"False",
"the",
"queued",
"events",
"are",
"not",
"dispatched",
"and",
"should",
"be",
"processed",
"manually",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L90-L105
|
11,849
|
pyviz/param
|
param/parameterized.py
|
get_all_slots
|
def get_all_slots(class_):
"""
Return a list of slot names for slots defined in class_ and its
superclasses.
"""
# A subclass's __slots__ attribute does not contain slots defined
# in its superclass (the superclass' __slots__ end up as
# attributes of the subclass).
all_slots = []
parent_param_classes = [c for c in classlist(class_)[1::]]
for c in parent_param_classes:
if hasattr(c,'__slots__'):
all_slots+=c.__slots__
return all_slots
|
python
|
def get_all_slots(class_):
"""
Return a list of slot names for slots defined in class_ and its
superclasses.
"""
# A subclass's __slots__ attribute does not contain slots defined
# in its superclass (the superclass' __slots__ end up as
# attributes of the subclass).
all_slots = []
parent_param_classes = [c for c in classlist(class_)[1::]]
for c in parent_param_classes:
if hasattr(c,'__slots__'):
all_slots+=c.__slots__
return all_slots
|
[
"def",
"get_all_slots",
"(",
"class_",
")",
":",
"# A subclass's __slots__ attribute does not contain slots defined",
"# in its superclass (the superclass' __slots__ end up as",
"# attributes of the subclass).",
"all_slots",
"=",
"[",
"]",
"parent_param_classes",
"=",
"[",
"c",
"for",
"c",
"in",
"classlist",
"(",
"class_",
")",
"[",
"1",
":",
":",
"]",
"]",
"for",
"c",
"in",
"parent_param_classes",
":",
"if",
"hasattr",
"(",
"c",
",",
"'__slots__'",
")",
":",
"all_slots",
"+=",
"c",
".",
"__slots__",
"return",
"all_slots"
] |
Return a list of slot names for slots defined in class_ and its
superclasses.
|
[
"Return",
"a",
"list",
"of",
"slot",
"names",
"for",
"slots",
"defined",
"in",
"class_",
"and",
"its",
"superclasses",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L136-L149
|
11,850
|
pyviz/param
|
param/parameterized.py
|
get_occupied_slots
|
def get_occupied_slots(instance):
"""
Return a list of slots for which values have been set.
(While a slot might be defined, if a value for that slot hasn't
been set, then it's an AttributeError to request the slot's
value.)
"""
return [slot for slot in get_all_slots(type(instance))
if hasattr(instance,slot)]
|
python
|
def get_occupied_slots(instance):
"""
Return a list of slots for which values have been set.
(While a slot might be defined, if a value for that slot hasn't
been set, then it's an AttributeError to request the slot's
value.)
"""
return [slot for slot in get_all_slots(type(instance))
if hasattr(instance,slot)]
|
[
"def",
"get_occupied_slots",
"(",
"instance",
")",
":",
"return",
"[",
"slot",
"for",
"slot",
"in",
"get_all_slots",
"(",
"type",
"(",
"instance",
")",
")",
"if",
"hasattr",
"(",
"instance",
",",
"slot",
")",
"]"
] |
Return a list of slots for which values have been set.
(While a slot might be defined, if a value for that slot hasn't
been set, then it's an AttributeError to request the slot's
value.)
|
[
"Return",
"a",
"list",
"of",
"slots",
"for",
"which",
"values",
"have",
"been",
"set",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L152-L161
|
11,851
|
pyviz/param
|
param/parameterized.py
|
all_equal
|
def all_equal(arg1,arg2):
"""
Return a single boolean for arg1==arg2, even for numpy arrays
using element-wise comparison.
Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise.
If both objects have an '_infinitely_iterable' attribute, they are
not be zipped together and are compared directly instead.
"""
if all(hasattr(el, '_infinitely_iterable') for el in [arg1,arg2]):
return arg1==arg2
try:
return all(a1 == a2 for a1, a2 in zip(arg1, arg2))
except TypeError:
return arg1==arg2
|
python
|
def all_equal(arg1,arg2):
"""
Return a single boolean for arg1==arg2, even for numpy arrays
using element-wise comparison.
Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise.
If both objects have an '_infinitely_iterable' attribute, they are
not be zipped together and are compared directly instead.
"""
if all(hasattr(el, '_infinitely_iterable') for el in [arg1,arg2]):
return arg1==arg2
try:
return all(a1 == a2 for a1, a2 in zip(arg1, arg2))
except TypeError:
return arg1==arg2
|
[
"def",
"all_equal",
"(",
"arg1",
",",
"arg2",
")",
":",
"if",
"all",
"(",
"hasattr",
"(",
"el",
",",
"'_infinitely_iterable'",
")",
"for",
"el",
"in",
"[",
"arg1",
",",
"arg2",
"]",
")",
":",
"return",
"arg1",
"==",
"arg2",
"try",
":",
"return",
"all",
"(",
"a1",
"==",
"a2",
"for",
"a1",
",",
"a2",
"in",
"zip",
"(",
"arg1",
",",
"arg2",
")",
")",
"except",
"TypeError",
":",
"return",
"arg1",
"==",
"arg2"
] |
Return a single boolean for arg1==arg2, even for numpy arrays
using element-wise comparison.
Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise.
If both objects have an '_infinitely_iterable' attribute, they are
not be zipped together and are compared directly instead.
|
[
"Return",
"a",
"single",
"boolean",
"for",
"arg1",
"==",
"arg2",
"even",
"for",
"numpy",
"arrays",
"using",
"element",
"-",
"wise",
"comparison",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L164-L179
|
11,852
|
pyviz/param
|
param/parameterized.py
|
output
|
def output(func, *output, **kw):
"""
output allows annotating a method on a Parameterized class to
declare that it returns an output of a specific type. The outputs
of a Parameterized class can be queried using the
Parameterized.param.outputs method. By default the output will
inherit the method name but a custom name can be declared by
expressing the Parameter type using a keyword argument. Declaring
multiple return types using keywords is only supported in Python >= 3.6.
The simplest declaration simply declares the method returns an
object without any type guarantees, e.g.:
@output()
If a specific parameter type is specified this is a declaration
that the method will return a value of that type, e.g.:
@output(param.Number())
To override the default name of the output the type may be declared
as a keyword argument, e.g.:
@output(custom_name=param.Number())
Multiple outputs may be declared using keywords mapping from
output name to the type for Python >= 3.6 or using tuples of the
same format, which is supported for earlier versions, i.e. these
two declarations are equivalent:
@output(number=param.Number(), string=param.String())
@output(('number', param.Number()), ('string', param.String()))
output also accepts Python object types which will be upgraded to
a ClassSelector, e.g.:
@output(int)
"""
if output:
outputs = []
for i, out in enumerate(output):
i = i if len(output) > 1 else None
if isinstance(out, tuple) and len(out) == 2 and isinstance(out[0], str):
outputs.append(out+(i,))
elif isinstance(out, str):
outputs.append((out, Parameter(), i))
else:
outputs.append((None, out, i))
elif kw:
py_major = sys.version_info.major
py_minor = sys.version_info.minor
if (py_major < 3 or (py_major == 3 and py_minor < 6)) and len(kw) > 1:
raise ValueError('Multiple output declaration using keywords '
'only supported in Python >= 3.6.')
# (requires keywords to be kept ordered, which was not true in previous versions)
outputs = [(name, otype, i if len(kw) > 1 else None)
for i, (name, otype) in enumerate(kw.items())]
else:
outputs = [(None, Parameter(), None)]
names, processed = [], []
for name, otype, i in outputs:
if isinstance(otype, type):
if issubclass(otype, Parameter):
otype = otype()
else:
from .import ClassSelector
otype = ClassSelector(class_=otype)
elif isinstance(otype, tuple) and all(isinstance(t, type) for t in otype):
from .import ClassSelector
otype = ClassSelector(class_=otype)
if not isinstance(otype, Parameter):
raise ValueError('output type must be declared with a Parameter class, '
'instance or a Python object type.')
processed.append((name, otype, i))
names.append(name)
if len(set(names)) != len(names):
raise ValueError('When declaring multiple outputs each value '
'must be unique.')
_dinfo = getattr(func, '_dinfo', {})
_dinfo.update({'outputs': processed})
@wraps(func)
def _output(*args,**kw):
return func(*args,**kw)
_output._dinfo = _dinfo
return _output
|
python
|
def output(func, *output, **kw):
"""
output allows annotating a method on a Parameterized class to
declare that it returns an output of a specific type. The outputs
of a Parameterized class can be queried using the
Parameterized.param.outputs method. By default the output will
inherit the method name but a custom name can be declared by
expressing the Parameter type using a keyword argument. Declaring
multiple return types using keywords is only supported in Python >= 3.6.
The simplest declaration simply declares the method returns an
object without any type guarantees, e.g.:
@output()
If a specific parameter type is specified this is a declaration
that the method will return a value of that type, e.g.:
@output(param.Number())
To override the default name of the output the type may be declared
as a keyword argument, e.g.:
@output(custom_name=param.Number())
Multiple outputs may be declared using keywords mapping from
output name to the type for Python >= 3.6 or using tuples of the
same format, which is supported for earlier versions, i.e. these
two declarations are equivalent:
@output(number=param.Number(), string=param.String())
@output(('number', param.Number()), ('string', param.String()))
output also accepts Python object types which will be upgraded to
a ClassSelector, e.g.:
@output(int)
"""
if output:
outputs = []
for i, out in enumerate(output):
i = i if len(output) > 1 else None
if isinstance(out, tuple) and len(out) == 2 and isinstance(out[0], str):
outputs.append(out+(i,))
elif isinstance(out, str):
outputs.append((out, Parameter(), i))
else:
outputs.append((None, out, i))
elif kw:
py_major = sys.version_info.major
py_minor = sys.version_info.minor
if (py_major < 3 or (py_major == 3 and py_minor < 6)) and len(kw) > 1:
raise ValueError('Multiple output declaration using keywords '
'only supported in Python >= 3.6.')
# (requires keywords to be kept ordered, which was not true in previous versions)
outputs = [(name, otype, i if len(kw) > 1 else None)
for i, (name, otype) in enumerate(kw.items())]
else:
outputs = [(None, Parameter(), None)]
names, processed = [], []
for name, otype, i in outputs:
if isinstance(otype, type):
if issubclass(otype, Parameter):
otype = otype()
else:
from .import ClassSelector
otype = ClassSelector(class_=otype)
elif isinstance(otype, tuple) and all(isinstance(t, type) for t in otype):
from .import ClassSelector
otype = ClassSelector(class_=otype)
if not isinstance(otype, Parameter):
raise ValueError('output type must be declared with a Parameter class, '
'instance or a Python object type.')
processed.append((name, otype, i))
names.append(name)
if len(set(names)) != len(names):
raise ValueError('When declaring multiple outputs each value '
'must be unique.')
_dinfo = getattr(func, '_dinfo', {})
_dinfo.update({'outputs': processed})
@wraps(func)
def _output(*args,**kw):
return func(*args,**kw)
_output._dinfo = _dinfo
return _output
|
[
"def",
"output",
"(",
"func",
",",
"*",
"output",
",",
"*",
"*",
"kw",
")",
":",
"if",
"output",
":",
"outputs",
"=",
"[",
"]",
"for",
"i",
",",
"out",
"in",
"enumerate",
"(",
"output",
")",
":",
"i",
"=",
"i",
"if",
"len",
"(",
"output",
")",
">",
"1",
"else",
"None",
"if",
"isinstance",
"(",
"out",
",",
"tuple",
")",
"and",
"len",
"(",
"out",
")",
"==",
"2",
"and",
"isinstance",
"(",
"out",
"[",
"0",
"]",
",",
"str",
")",
":",
"outputs",
".",
"append",
"(",
"out",
"+",
"(",
"i",
",",
")",
")",
"elif",
"isinstance",
"(",
"out",
",",
"str",
")",
":",
"outputs",
".",
"append",
"(",
"(",
"out",
",",
"Parameter",
"(",
")",
",",
"i",
")",
")",
"else",
":",
"outputs",
".",
"append",
"(",
"(",
"None",
",",
"out",
",",
"i",
")",
")",
"elif",
"kw",
":",
"py_major",
"=",
"sys",
".",
"version_info",
".",
"major",
"py_minor",
"=",
"sys",
".",
"version_info",
".",
"minor",
"if",
"(",
"py_major",
"<",
"3",
"or",
"(",
"py_major",
"==",
"3",
"and",
"py_minor",
"<",
"6",
")",
")",
"and",
"len",
"(",
"kw",
")",
">",
"1",
":",
"raise",
"ValueError",
"(",
"'Multiple output declaration using keywords '",
"'only supported in Python >= 3.6.'",
")",
"# (requires keywords to be kept ordered, which was not true in previous versions)",
"outputs",
"=",
"[",
"(",
"name",
",",
"otype",
",",
"i",
"if",
"len",
"(",
"kw",
")",
">",
"1",
"else",
"None",
")",
"for",
"i",
",",
"(",
"name",
",",
"otype",
")",
"in",
"enumerate",
"(",
"kw",
".",
"items",
"(",
")",
")",
"]",
"else",
":",
"outputs",
"=",
"[",
"(",
"None",
",",
"Parameter",
"(",
")",
",",
"None",
")",
"]",
"names",
",",
"processed",
"=",
"[",
"]",
",",
"[",
"]",
"for",
"name",
",",
"otype",
",",
"i",
"in",
"outputs",
":",
"if",
"isinstance",
"(",
"otype",
",",
"type",
")",
":",
"if",
"issubclass",
"(",
"otype",
",",
"Parameter",
")",
":",
"otype",
"=",
"otype",
"(",
")",
"else",
":",
"from",
".",
"import",
"ClassSelector",
"otype",
"=",
"ClassSelector",
"(",
"class_",
"=",
"otype",
")",
"elif",
"isinstance",
"(",
"otype",
",",
"tuple",
")",
"and",
"all",
"(",
"isinstance",
"(",
"t",
",",
"type",
")",
"for",
"t",
"in",
"otype",
")",
":",
"from",
".",
"import",
"ClassSelector",
"otype",
"=",
"ClassSelector",
"(",
"class_",
"=",
"otype",
")",
"if",
"not",
"isinstance",
"(",
"otype",
",",
"Parameter",
")",
":",
"raise",
"ValueError",
"(",
"'output type must be declared with a Parameter class, '",
"'instance or a Python object type.'",
")",
"processed",
".",
"append",
"(",
"(",
"name",
",",
"otype",
",",
"i",
")",
")",
"names",
".",
"append",
"(",
"name",
")",
"if",
"len",
"(",
"set",
"(",
"names",
")",
")",
"!=",
"len",
"(",
"names",
")",
":",
"raise",
"ValueError",
"(",
"'When declaring multiple outputs each value '",
"'must be unique.'",
")",
"_dinfo",
"=",
"getattr",
"(",
"func",
",",
"'_dinfo'",
",",
"{",
"}",
")",
"_dinfo",
".",
"update",
"(",
"{",
"'outputs'",
":",
"processed",
"}",
")",
"@",
"wraps",
"(",
"func",
")",
"def",
"_output",
"(",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"return",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"kw",
")",
"_output",
".",
"_dinfo",
"=",
"_dinfo",
"return",
"_output"
] |
output allows annotating a method on a Parameterized class to
declare that it returns an output of a specific type. The outputs
of a Parameterized class can be queried using the
Parameterized.param.outputs method. By default the output will
inherit the method name but a custom name can be declared by
expressing the Parameter type using a keyword argument. Declaring
multiple return types using keywords is only supported in Python >= 3.6.
The simplest declaration simply declares the method returns an
object without any type guarantees, e.g.:
@output()
If a specific parameter type is specified this is a declaration
that the method will return a value of that type, e.g.:
@output(param.Number())
To override the default name of the output the type may be declared
as a keyword argument, e.g.:
@output(custom_name=param.Number())
Multiple outputs may be declared using keywords mapping from
output name to the type for Python >= 3.6 or using tuples of the
same format, which is supported for earlier versions, i.e. these
two declarations are equivalent:
@output(number=param.Number(), string=param.String())
@output(('number', param.Number()), ('string', param.String()))
output also accepts Python object types which will be upgraded to
a ClassSelector, e.g.:
@output(int)
|
[
"output",
"allows",
"annotating",
"a",
"method",
"on",
"a",
"Parameterized",
"class",
"to",
"declare",
"that",
"it",
"returns",
"an",
"output",
"of",
"a",
"specific",
"type",
".",
"The",
"outputs",
"of",
"a",
"Parameterized",
"class",
"can",
"be",
"queried",
"using",
"the",
"Parameterized",
".",
"param",
".",
"outputs",
"method",
".",
"By",
"default",
"the",
"output",
"will",
"inherit",
"the",
"method",
"name",
"but",
"a",
"custom",
"name",
"can",
"be",
"declared",
"by",
"expressing",
"the",
"Parameter",
"type",
"using",
"a",
"keyword",
"argument",
".",
"Declaring",
"multiple",
"return",
"types",
"using",
"keywords",
"is",
"only",
"supported",
"in",
"Python",
">",
"=",
"3",
".",
"6",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L293-L384
|
11,853
|
pyviz/param
|
param/parameterized.py
|
Parameters._setup_params
|
def _setup_params(self_,**params):
"""
Initialize default and keyword parameter values.
First, ensures that all Parameters with 'instantiate=True'
(typically used for mutable Parameters) are copied directly
into each object, to ensure that there is an independent copy
(to avoid suprising aliasing errors). Then sets each of the
keyword arguments, warning when any of them are not defined as
parameters.
Constant Parameters can be set during calls to this method.
"""
self = self_.param.self
## Deepcopy all 'instantiate=True' parameters
# (build a set of names first to avoid redundantly instantiating
# a later-overridden parent class's parameter)
params_to_instantiate = {}
for class_ in classlist(type(self)):
if not issubclass(class_, Parameterized):
continue
for (k,v) in class_.__dict__.items():
# (avoid replacing name with the default of None)
if isinstance(v,Parameter) and v.instantiate and k!="name":
params_to_instantiate[k]=v
for p in params_to_instantiate.values():
self.param._instantiate_param(p)
## keyword arg setting
for name,val in params.items():
desc = self.__class__.get_param_descriptor(name)[0] # pylint: disable-msg=E1101
if not desc:
self.param.warning("Setting non-parameter attribute %s=%s using a mechanism intended only for parameters",name,val)
# i.e. if not desc it's setting an attribute in __dict__, not a Parameter
setattr(self,name,val)
|
python
|
def _setup_params(self_,**params):
"""
Initialize default and keyword parameter values.
First, ensures that all Parameters with 'instantiate=True'
(typically used for mutable Parameters) are copied directly
into each object, to ensure that there is an independent copy
(to avoid suprising aliasing errors). Then sets each of the
keyword arguments, warning when any of them are not defined as
parameters.
Constant Parameters can be set during calls to this method.
"""
self = self_.param.self
## Deepcopy all 'instantiate=True' parameters
# (build a set of names first to avoid redundantly instantiating
# a later-overridden parent class's parameter)
params_to_instantiate = {}
for class_ in classlist(type(self)):
if not issubclass(class_, Parameterized):
continue
for (k,v) in class_.__dict__.items():
# (avoid replacing name with the default of None)
if isinstance(v,Parameter) and v.instantiate and k!="name":
params_to_instantiate[k]=v
for p in params_to_instantiate.values():
self.param._instantiate_param(p)
## keyword arg setting
for name,val in params.items():
desc = self.__class__.get_param_descriptor(name)[0] # pylint: disable-msg=E1101
if not desc:
self.param.warning("Setting non-parameter attribute %s=%s using a mechanism intended only for parameters",name,val)
# i.e. if not desc it's setting an attribute in __dict__, not a Parameter
setattr(self,name,val)
|
[
"def",
"_setup_params",
"(",
"self_",
",",
"*",
"*",
"params",
")",
":",
"self",
"=",
"self_",
".",
"param",
".",
"self",
"## Deepcopy all 'instantiate=True' parameters",
"# (build a set of names first to avoid redundantly instantiating",
"# a later-overridden parent class's parameter)",
"params_to_instantiate",
"=",
"{",
"}",
"for",
"class_",
"in",
"classlist",
"(",
"type",
"(",
"self",
")",
")",
":",
"if",
"not",
"issubclass",
"(",
"class_",
",",
"Parameterized",
")",
":",
"continue",
"for",
"(",
"k",
",",
"v",
")",
"in",
"class_",
".",
"__dict__",
".",
"items",
"(",
")",
":",
"# (avoid replacing name with the default of None)",
"if",
"isinstance",
"(",
"v",
",",
"Parameter",
")",
"and",
"v",
".",
"instantiate",
"and",
"k",
"!=",
"\"name\"",
":",
"params_to_instantiate",
"[",
"k",
"]",
"=",
"v",
"for",
"p",
"in",
"params_to_instantiate",
".",
"values",
"(",
")",
":",
"self",
".",
"param",
".",
"_instantiate_param",
"(",
"p",
")",
"## keyword arg setting",
"for",
"name",
",",
"val",
"in",
"params",
".",
"items",
"(",
")",
":",
"desc",
"=",
"self",
".",
"__class__",
".",
"get_param_descriptor",
"(",
"name",
")",
"[",
"0",
"]",
"# pylint: disable-msg=E1101",
"if",
"not",
"desc",
":",
"self",
".",
"param",
".",
"warning",
"(",
"\"Setting non-parameter attribute %s=%s using a mechanism intended only for parameters\"",
",",
"name",
",",
"val",
")",
"# i.e. if not desc it's setting an attribute in __dict__, not a Parameter",
"setattr",
"(",
"self",
",",
"name",
",",
"val",
")"
] |
Initialize default and keyword parameter values.
First, ensures that all Parameters with 'instantiate=True'
(typically used for mutable Parameters) are copied directly
into each object, to ensure that there is an independent copy
(to avoid suprising aliasing errors). Then sets each of the
keyword arguments, warning when any of them are not defined as
parameters.
Constant Parameters can be set during calls to this method.
|
[
"Initialize",
"default",
"and",
"keyword",
"parameter",
"values",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1094-L1129
|
11,854
|
pyviz/param
|
param/parameterized.py
|
Parameters.deprecate
|
def deprecate(cls, fn):
"""
Decorator to issue warnings for API moving onto the param
namespace and to add a docstring directing people to the
appropriate method.
"""
def inner(*args, **kwargs):
if cls._disable_stubs:
raise AssertionError('Stubs supporting old API disabled')
elif cls._disable_stubs is None:
pass
elif cls._disable_stubs is False:
get_logger(name=args[0].__class__.__name__).log(
WARNING, 'Use method %r via param namespace ' % fn.__name__)
return fn(*args, **kwargs)
inner.__doc__= "Inspect .param.%s method for the full docstring" % fn.__name__
return inner
|
python
|
def deprecate(cls, fn):
"""
Decorator to issue warnings for API moving onto the param
namespace and to add a docstring directing people to the
appropriate method.
"""
def inner(*args, **kwargs):
if cls._disable_stubs:
raise AssertionError('Stubs supporting old API disabled')
elif cls._disable_stubs is None:
pass
elif cls._disable_stubs is False:
get_logger(name=args[0].__class__.__name__).log(
WARNING, 'Use method %r via param namespace ' % fn.__name__)
return fn(*args, **kwargs)
inner.__doc__= "Inspect .param.%s method for the full docstring" % fn.__name__
return inner
|
[
"def",
"deprecate",
"(",
"cls",
",",
"fn",
")",
":",
"def",
"inner",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"cls",
".",
"_disable_stubs",
":",
"raise",
"AssertionError",
"(",
"'Stubs supporting old API disabled'",
")",
"elif",
"cls",
".",
"_disable_stubs",
"is",
"None",
":",
"pass",
"elif",
"cls",
".",
"_disable_stubs",
"is",
"False",
":",
"get_logger",
"(",
"name",
"=",
"args",
"[",
"0",
"]",
".",
"__class__",
".",
"__name__",
")",
".",
"log",
"(",
"WARNING",
",",
"'Use method %r via param namespace '",
"%",
"fn",
".",
"__name__",
")",
"return",
"fn",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"inner",
".",
"__doc__",
"=",
"\"Inspect .param.%s method for the full docstring\"",
"%",
"fn",
".",
"__name__",
"return",
"inner"
] |
Decorator to issue warnings for API moving onto the param
namespace and to add a docstring directing people to the
appropriate method.
|
[
"Decorator",
"to",
"issue",
"warnings",
"for",
"API",
"moving",
"onto",
"the",
"param",
"namespace",
"and",
"to",
"add",
"a",
"docstring",
"directing",
"people",
"to",
"the",
"appropriate",
"method",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1132-L1149
|
11,855
|
pyviz/param
|
param/parameterized.py
|
Parameters.print_param_defaults
|
def print_param_defaults(self_):
"""Print the default values of all cls's Parameters."""
cls = self_.cls
for key,val in cls.__dict__.items():
if isinstance(val,Parameter):
print(cls.__name__+'.'+key+ '='+ repr(val.default))
|
python
|
def print_param_defaults(self_):
"""Print the default values of all cls's Parameters."""
cls = self_.cls
for key,val in cls.__dict__.items():
if isinstance(val,Parameter):
print(cls.__name__+'.'+key+ '='+ repr(val.default))
|
[
"def",
"print_param_defaults",
"(",
"self_",
")",
":",
"cls",
"=",
"self_",
".",
"cls",
"for",
"key",
",",
"val",
"in",
"cls",
".",
"__dict__",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"val",
",",
"Parameter",
")",
":",
"print",
"(",
"cls",
".",
"__name__",
"+",
"'.'",
"+",
"key",
"+",
"'='",
"+",
"repr",
"(",
"val",
".",
"default",
")",
")"
] |
Print the default values of all cls's Parameters.
|
[
"Print",
"the",
"default",
"values",
"of",
"all",
"cls",
"s",
"Parameters",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1188-L1193
|
11,856
|
pyviz/param
|
param/parameterized.py
|
Parameters.set_default
|
def set_default(self_,param_name,value):
"""
Set the default value of param_name.
Equivalent to setting param_name on the class.
"""
cls = self_.cls
setattr(cls,param_name,value)
|
python
|
def set_default(self_,param_name,value):
"""
Set the default value of param_name.
Equivalent to setting param_name on the class.
"""
cls = self_.cls
setattr(cls,param_name,value)
|
[
"def",
"set_default",
"(",
"self_",
",",
"param_name",
",",
"value",
")",
":",
"cls",
"=",
"self_",
".",
"cls",
"setattr",
"(",
"cls",
",",
"param_name",
",",
"value",
")"
] |
Set the default value of param_name.
Equivalent to setting param_name on the class.
|
[
"Set",
"the",
"default",
"value",
"of",
"param_name",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1196-L1203
|
11,857
|
pyviz/param
|
param/parameterized.py
|
Parameters._add_parameter
|
def _add_parameter(self_, param_name,param_obj):
"""
Add a new Parameter object into this object's class.
Supposed to result in a Parameter equivalent to one declared
in the class's source code.
"""
# CEBALERT: can't we just do
# setattr(cls,param_name,param_obj)? The metaclass's
# __setattr__ is actually written to handle that. (Would also
# need to do something about the params() cache. That cache
# is a pain, but it definitely improved the startup time; it
# would be worthwhile making sure no method except for one
# "add_param()" method has to deal with it (plus any future
# remove_param() method.)
cls = self_.cls
type.__setattr__(cls,param_name,param_obj)
ParameterizedMetaclass._initialize_parameter(cls,param_name,param_obj)
# delete cached params()
try:
delattr(cls,'_%s__params'%cls.__name__)
except AttributeError:
pass
|
python
|
def _add_parameter(self_, param_name,param_obj):
"""
Add a new Parameter object into this object's class.
Supposed to result in a Parameter equivalent to one declared
in the class's source code.
"""
# CEBALERT: can't we just do
# setattr(cls,param_name,param_obj)? The metaclass's
# __setattr__ is actually written to handle that. (Would also
# need to do something about the params() cache. That cache
# is a pain, but it definitely improved the startup time; it
# would be worthwhile making sure no method except for one
# "add_param()" method has to deal with it (plus any future
# remove_param() method.)
cls = self_.cls
type.__setattr__(cls,param_name,param_obj)
ParameterizedMetaclass._initialize_parameter(cls,param_name,param_obj)
# delete cached params()
try:
delattr(cls,'_%s__params'%cls.__name__)
except AttributeError:
pass
|
[
"def",
"_add_parameter",
"(",
"self_",
",",
"param_name",
",",
"param_obj",
")",
":",
"# CEBALERT: can't we just do",
"# setattr(cls,param_name,param_obj)? The metaclass's",
"# __setattr__ is actually written to handle that. (Would also",
"# need to do something about the params() cache. That cache",
"# is a pain, but it definitely improved the startup time; it",
"# would be worthwhile making sure no method except for one",
"# \"add_param()\" method has to deal with it (plus any future",
"# remove_param() method.)",
"cls",
"=",
"self_",
".",
"cls",
"type",
".",
"__setattr__",
"(",
"cls",
",",
"param_name",
",",
"param_obj",
")",
"ParameterizedMetaclass",
".",
"_initialize_parameter",
"(",
"cls",
",",
"param_name",
",",
"param_obj",
")",
"# delete cached params()",
"try",
":",
"delattr",
"(",
"cls",
",",
"'_%s__params'",
"%",
"cls",
".",
"__name__",
")",
"except",
"AttributeError",
":",
"pass"
] |
Add a new Parameter object into this object's class.
Supposed to result in a Parameter equivalent to one declared
in the class's source code.
|
[
"Add",
"a",
"new",
"Parameter",
"object",
"into",
"this",
"object",
"s",
"class",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1206-L1228
|
11,858
|
pyviz/param
|
param/parameterized.py
|
Parameters.set_param
|
def set_param(self_, *args,**kwargs):
"""
For each param=value keyword argument, sets the corresponding
parameter of this object or class to the given value.
For backwards compatibility, also accepts
set_param("param",value) for a single parameter value using
positional arguments, but the keyword interface is preferred
because it is more compact and can set multiple values.
"""
BATCH_WATCH = self_.self_or_cls.param._BATCH_WATCH
self_.self_or_cls.param._BATCH_WATCH = True
self_or_cls = self_.self_or_cls
if args:
if len(args) == 2 and not args[0] in kwargs and not kwargs:
kwargs[args[0]] = args[1]
else:
self_.self_or_cls.param._BATCH_WATCH = False
raise ValueError("Invalid positional arguments for %s.set_param" %
(self_or_cls.name))
for (k, v) in kwargs.items():
if k not in self_or_cls.param:
self_.self_or_cls.param._BATCH_WATCH = False
raise ValueError("'%s' is not a parameter of %s" % (k, self_or_cls.name))
try:
setattr(self_or_cls, k, v)
except:
self_.self_or_cls.param._BATCH_WATCH = False
raise
self_.self_or_cls.param._BATCH_WATCH = BATCH_WATCH
if not BATCH_WATCH:
self_._batch_call_watchers()
|
python
|
def set_param(self_, *args,**kwargs):
"""
For each param=value keyword argument, sets the corresponding
parameter of this object or class to the given value.
For backwards compatibility, also accepts
set_param("param",value) for a single parameter value using
positional arguments, but the keyword interface is preferred
because it is more compact and can set multiple values.
"""
BATCH_WATCH = self_.self_or_cls.param._BATCH_WATCH
self_.self_or_cls.param._BATCH_WATCH = True
self_or_cls = self_.self_or_cls
if args:
if len(args) == 2 and not args[0] in kwargs and not kwargs:
kwargs[args[0]] = args[1]
else:
self_.self_or_cls.param._BATCH_WATCH = False
raise ValueError("Invalid positional arguments for %s.set_param" %
(self_or_cls.name))
for (k, v) in kwargs.items():
if k not in self_or_cls.param:
self_.self_or_cls.param._BATCH_WATCH = False
raise ValueError("'%s' is not a parameter of %s" % (k, self_or_cls.name))
try:
setattr(self_or_cls, k, v)
except:
self_.self_or_cls.param._BATCH_WATCH = False
raise
self_.self_or_cls.param._BATCH_WATCH = BATCH_WATCH
if not BATCH_WATCH:
self_._batch_call_watchers()
|
[
"def",
"set_param",
"(",
"self_",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"BATCH_WATCH",
"=",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"True",
"self_or_cls",
"=",
"self_",
".",
"self_or_cls",
"if",
"args",
":",
"if",
"len",
"(",
"args",
")",
"==",
"2",
"and",
"not",
"args",
"[",
"0",
"]",
"in",
"kwargs",
"and",
"not",
"kwargs",
":",
"kwargs",
"[",
"args",
"[",
"0",
"]",
"]",
"=",
"args",
"[",
"1",
"]",
"else",
":",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"False",
"raise",
"ValueError",
"(",
"\"Invalid positional arguments for %s.set_param\"",
"%",
"(",
"self_or_cls",
".",
"name",
")",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"if",
"k",
"not",
"in",
"self_or_cls",
".",
"param",
":",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"False",
"raise",
"ValueError",
"(",
"\"'%s' is not a parameter of %s\"",
"%",
"(",
"k",
",",
"self_or_cls",
".",
"name",
")",
")",
"try",
":",
"setattr",
"(",
"self_or_cls",
",",
"k",
",",
"v",
")",
"except",
":",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"False",
"raise",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
"=",
"BATCH_WATCH",
"if",
"not",
"BATCH_WATCH",
":",
"self_",
".",
"_batch_call_watchers",
"(",
")"
] |
For each param=value keyword argument, sets the corresponding
parameter of this object or class to the given value.
For backwards compatibility, also accepts
set_param("param",value) for a single parameter value using
positional arguments, but the keyword interface is preferred
because it is more compact and can set multiple values.
|
[
"For",
"each",
"param",
"=",
"value",
"keyword",
"argument",
"sets",
"the",
"corresponding",
"parameter",
"of",
"this",
"object",
"or",
"class",
"to",
"the",
"given",
"value",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1259-L1292
|
11,859
|
pyviz/param
|
param/parameterized.py
|
Parameters.objects
|
def objects(self_, instance=True):
"""
Returns the Parameters of this instance or class
If instance=True and called on a Parameterized instance it
will create instance parameters for all Parameters defined on
the class. To force class parameters to be returned use
instance=False. Since classes avoid creating instance
parameters unless necessary you may also request only existing
instance parameters to be returned by setting
instance='existing'.
"""
cls = self_.cls
# CB: we cache the parameters because this method is called often,
# and parameters are rarely added (and cannot be deleted)
try:
pdict = getattr(cls, '_%s__params' % cls.__name__)
except AttributeError:
paramdict = {}
for class_ in classlist(cls):
for name, val in class_.__dict__.items():
if isinstance(val, Parameter):
paramdict[name] = val
# We only want the cache to be visible to the cls on which
# params() is called, so we mangle the name ourselves at
# runtime (if we were to mangle it now, it would be
# _Parameterized.__params for all classes).
setattr(cls, '_%s__params' % cls.__name__, paramdict)
pdict = paramdict
if instance and self_.self is not None:
if instance == 'existing':
if self_.self._instance__params:
return dict(pdict, **self_.self._instance__params)
return pdict
else:
return {k: self_.self.param[k] for k in pdict}
return pdict
|
python
|
def objects(self_, instance=True):
"""
Returns the Parameters of this instance or class
If instance=True and called on a Parameterized instance it
will create instance parameters for all Parameters defined on
the class. To force class parameters to be returned use
instance=False. Since classes avoid creating instance
parameters unless necessary you may also request only existing
instance parameters to be returned by setting
instance='existing'.
"""
cls = self_.cls
# CB: we cache the parameters because this method is called often,
# and parameters are rarely added (and cannot be deleted)
try:
pdict = getattr(cls, '_%s__params' % cls.__name__)
except AttributeError:
paramdict = {}
for class_ in classlist(cls):
for name, val in class_.__dict__.items():
if isinstance(val, Parameter):
paramdict[name] = val
# We only want the cache to be visible to the cls on which
# params() is called, so we mangle the name ourselves at
# runtime (if we were to mangle it now, it would be
# _Parameterized.__params for all classes).
setattr(cls, '_%s__params' % cls.__name__, paramdict)
pdict = paramdict
if instance and self_.self is not None:
if instance == 'existing':
if self_.self._instance__params:
return dict(pdict, **self_.self._instance__params)
return pdict
else:
return {k: self_.self.param[k] for k in pdict}
return pdict
|
[
"def",
"objects",
"(",
"self_",
",",
"instance",
"=",
"True",
")",
":",
"cls",
"=",
"self_",
".",
"cls",
"# CB: we cache the parameters because this method is called often,",
"# and parameters are rarely added (and cannot be deleted)",
"try",
":",
"pdict",
"=",
"getattr",
"(",
"cls",
",",
"'_%s__params'",
"%",
"cls",
".",
"__name__",
")",
"except",
"AttributeError",
":",
"paramdict",
"=",
"{",
"}",
"for",
"class_",
"in",
"classlist",
"(",
"cls",
")",
":",
"for",
"name",
",",
"val",
"in",
"class_",
".",
"__dict__",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"val",
",",
"Parameter",
")",
":",
"paramdict",
"[",
"name",
"]",
"=",
"val",
"# We only want the cache to be visible to the cls on which",
"# params() is called, so we mangle the name ourselves at",
"# runtime (if we were to mangle it now, it would be",
"# _Parameterized.__params for all classes).",
"setattr",
"(",
"cls",
",",
"'_%s__params'",
"%",
"cls",
".",
"__name__",
",",
"paramdict",
")",
"pdict",
"=",
"paramdict",
"if",
"instance",
"and",
"self_",
".",
"self",
"is",
"not",
"None",
":",
"if",
"instance",
"==",
"'existing'",
":",
"if",
"self_",
".",
"self",
".",
"_instance__params",
":",
"return",
"dict",
"(",
"pdict",
",",
"*",
"*",
"self_",
".",
"self",
".",
"_instance__params",
")",
"return",
"pdict",
"else",
":",
"return",
"{",
"k",
":",
"self_",
".",
"self",
".",
"param",
"[",
"k",
"]",
"for",
"k",
"in",
"pdict",
"}",
"return",
"pdict"
] |
Returns the Parameters of this instance or class
If instance=True and called on a Parameterized instance it
will create instance parameters for all Parameters defined on
the class. To force class parameters to be returned use
instance=False. Since classes avoid creating instance
parameters unless necessary you may also request only existing
instance parameters to be returned by setting
instance='existing'.
|
[
"Returns",
"the",
"Parameters",
"of",
"this",
"instance",
"or",
"class"
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1295-L1333
|
11,860
|
pyviz/param
|
param/parameterized.py
|
Parameters.trigger
|
def trigger(self_, *param_names):
"""
Trigger watchers for the given set of parameter names. Watchers
will be triggered whether or not the parameter values have
actually changed.
"""
events = self_.self_or_cls.param._events
watchers = self_.self_or_cls.param._watchers
self_.self_or_cls.param._events = []
self_.self_or_cls.param._watchers = []
param_values = dict(self_.get_param_values())
params = {name: param_values[name] for name in param_names}
self_.self_or_cls.param._TRIGGER = True
self_.set_param(**params)
self_.self_or_cls.param._TRIGGER = False
self_.self_or_cls.param._events = events
self_.self_or_cls.param._watchers = watchers
|
python
|
def trigger(self_, *param_names):
"""
Trigger watchers for the given set of parameter names. Watchers
will be triggered whether or not the parameter values have
actually changed.
"""
events = self_.self_or_cls.param._events
watchers = self_.self_or_cls.param._watchers
self_.self_or_cls.param._events = []
self_.self_or_cls.param._watchers = []
param_values = dict(self_.get_param_values())
params = {name: param_values[name] for name in param_names}
self_.self_or_cls.param._TRIGGER = True
self_.set_param(**params)
self_.self_or_cls.param._TRIGGER = False
self_.self_or_cls.param._events = events
self_.self_or_cls.param._watchers = watchers
|
[
"def",
"trigger",
"(",
"self_",
",",
"*",
"param_names",
")",
":",
"events",
"=",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_events",
"watchers",
"=",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_watchers",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_events",
"=",
"[",
"]",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_watchers",
"=",
"[",
"]",
"param_values",
"=",
"dict",
"(",
"self_",
".",
"get_param_values",
"(",
")",
")",
"params",
"=",
"{",
"name",
":",
"param_values",
"[",
"name",
"]",
"for",
"name",
"in",
"param_names",
"}",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_TRIGGER",
"=",
"True",
"self_",
".",
"set_param",
"(",
"*",
"*",
"params",
")",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_TRIGGER",
"=",
"False",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_events",
"=",
"events",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_watchers",
"=",
"watchers"
] |
Trigger watchers for the given set of parameter names. Watchers
will be triggered whether or not the parameter values have
actually changed.
|
[
"Trigger",
"watchers",
"for",
"the",
"given",
"set",
"of",
"parameter",
"names",
".",
"Watchers",
"will",
"be",
"triggered",
"whether",
"or",
"not",
"the",
"parameter",
"values",
"have",
"actually",
"changed",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1336-L1352
|
11,861
|
pyviz/param
|
param/parameterized.py
|
Parameters._update_event_type
|
def _update_event_type(self_, watcher, event, triggered):
"""
Returns an updated Event object with the type field set appropriately.
"""
if triggered:
event_type = 'triggered'
else:
event_type = 'changed' if watcher.onlychanged else 'set'
return Event(what=event.what, name=event.name, obj=event.obj, cls=event.cls,
old=event.old, new=event.new, type=event_type)
|
python
|
def _update_event_type(self_, watcher, event, triggered):
"""
Returns an updated Event object with the type field set appropriately.
"""
if triggered:
event_type = 'triggered'
else:
event_type = 'changed' if watcher.onlychanged else 'set'
return Event(what=event.what, name=event.name, obj=event.obj, cls=event.cls,
old=event.old, new=event.new, type=event_type)
|
[
"def",
"_update_event_type",
"(",
"self_",
",",
"watcher",
",",
"event",
",",
"triggered",
")",
":",
"if",
"triggered",
":",
"event_type",
"=",
"'triggered'",
"else",
":",
"event_type",
"=",
"'changed'",
"if",
"watcher",
".",
"onlychanged",
"else",
"'set'",
"return",
"Event",
"(",
"what",
"=",
"event",
".",
"what",
",",
"name",
"=",
"event",
".",
"name",
",",
"obj",
"=",
"event",
".",
"obj",
",",
"cls",
"=",
"event",
".",
"cls",
",",
"old",
"=",
"event",
".",
"old",
",",
"new",
"=",
"event",
".",
"new",
",",
"type",
"=",
"event_type",
")"
] |
Returns an updated Event object with the type field set appropriately.
|
[
"Returns",
"an",
"updated",
"Event",
"object",
"with",
"the",
"type",
"field",
"set",
"appropriately",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1355-L1364
|
11,862
|
pyviz/param
|
param/parameterized.py
|
Parameters._call_watcher
|
def _call_watcher(self_, watcher, event):
"""
Invoke the given the watcher appropriately given a Event object.
"""
if self_.self_or_cls.param._TRIGGER:
pass
elif watcher.onlychanged and (not self_._changed(event)):
return
if self_.self_or_cls.param._BATCH_WATCH:
self_._events.append(event)
if watcher not in self_._watchers:
self_._watchers.append(watcher)
elif watcher.mode == 'args':
with batch_watch(self_.self_or_cls, run=False):
watcher.fn(self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER))
else:
with batch_watch(self_.self_or_cls, run=False):
event = self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER)
watcher.fn(**{event.name: event.new})
|
python
|
def _call_watcher(self_, watcher, event):
"""
Invoke the given the watcher appropriately given a Event object.
"""
if self_.self_or_cls.param._TRIGGER:
pass
elif watcher.onlychanged and (not self_._changed(event)):
return
if self_.self_or_cls.param._BATCH_WATCH:
self_._events.append(event)
if watcher not in self_._watchers:
self_._watchers.append(watcher)
elif watcher.mode == 'args':
with batch_watch(self_.self_or_cls, run=False):
watcher.fn(self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER))
else:
with batch_watch(self_.self_or_cls, run=False):
event = self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER)
watcher.fn(**{event.name: event.new})
|
[
"def",
"_call_watcher",
"(",
"self_",
",",
"watcher",
",",
"event",
")",
":",
"if",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_TRIGGER",
":",
"pass",
"elif",
"watcher",
".",
"onlychanged",
"and",
"(",
"not",
"self_",
".",
"_changed",
"(",
"event",
")",
")",
":",
"return",
"if",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_BATCH_WATCH",
":",
"self_",
".",
"_events",
".",
"append",
"(",
"event",
")",
"if",
"watcher",
"not",
"in",
"self_",
".",
"_watchers",
":",
"self_",
".",
"_watchers",
".",
"append",
"(",
"watcher",
")",
"elif",
"watcher",
".",
"mode",
"==",
"'args'",
":",
"with",
"batch_watch",
"(",
"self_",
".",
"self_or_cls",
",",
"run",
"=",
"False",
")",
":",
"watcher",
".",
"fn",
"(",
"self_",
".",
"_update_event_type",
"(",
"watcher",
",",
"event",
",",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_TRIGGER",
")",
")",
"else",
":",
"with",
"batch_watch",
"(",
"self_",
".",
"self_or_cls",
",",
"run",
"=",
"False",
")",
":",
"event",
"=",
"self_",
".",
"_update_event_type",
"(",
"watcher",
",",
"event",
",",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_TRIGGER",
")",
"watcher",
".",
"fn",
"(",
"*",
"*",
"{",
"event",
".",
"name",
":",
"event",
".",
"new",
"}",
")"
] |
Invoke the given the watcher appropriately given a Event object.
|
[
"Invoke",
"the",
"given",
"the",
"watcher",
"appropriately",
"given",
"a",
"Event",
"object",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1366-L1385
|
11,863
|
pyviz/param
|
param/parameterized.py
|
Parameters._batch_call_watchers
|
def _batch_call_watchers(self_):
"""
Batch call a set of watchers based on the parameter value
settings in kwargs using the queued Event and watcher objects.
"""
while self_.self_or_cls.param._events:
event_dict = OrderedDict([((event.name, event.what), event)
for event in self_.self_or_cls.param._events])
watchers = self_.self_or_cls.param._watchers[:]
self_.self_or_cls.param._events = []
self_.self_or_cls.param._watchers = []
for watcher in watchers:
events = [self_._update_event_type(watcher, event_dict[(name, watcher.what)],
self_.self_or_cls.param._TRIGGER)
for name in watcher.parameter_names
if (name, watcher.what) in event_dict]
with batch_watch(self_.self_or_cls, run=False):
if watcher.mode == 'args':
watcher.fn(*events)
else:
watcher.fn(**{c.name:c.new for c in events})
|
python
|
def _batch_call_watchers(self_):
"""
Batch call a set of watchers based on the parameter value
settings in kwargs using the queued Event and watcher objects.
"""
while self_.self_or_cls.param._events:
event_dict = OrderedDict([((event.name, event.what), event)
for event in self_.self_or_cls.param._events])
watchers = self_.self_or_cls.param._watchers[:]
self_.self_or_cls.param._events = []
self_.self_or_cls.param._watchers = []
for watcher in watchers:
events = [self_._update_event_type(watcher, event_dict[(name, watcher.what)],
self_.self_or_cls.param._TRIGGER)
for name in watcher.parameter_names
if (name, watcher.what) in event_dict]
with batch_watch(self_.self_or_cls, run=False):
if watcher.mode == 'args':
watcher.fn(*events)
else:
watcher.fn(**{c.name:c.new for c in events})
|
[
"def",
"_batch_call_watchers",
"(",
"self_",
")",
":",
"while",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_events",
":",
"event_dict",
"=",
"OrderedDict",
"(",
"[",
"(",
"(",
"event",
".",
"name",
",",
"event",
".",
"what",
")",
",",
"event",
")",
"for",
"event",
"in",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_events",
"]",
")",
"watchers",
"=",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_watchers",
"[",
":",
"]",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_events",
"=",
"[",
"]",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_watchers",
"=",
"[",
"]",
"for",
"watcher",
"in",
"watchers",
":",
"events",
"=",
"[",
"self_",
".",
"_update_event_type",
"(",
"watcher",
",",
"event_dict",
"[",
"(",
"name",
",",
"watcher",
".",
"what",
")",
"]",
",",
"self_",
".",
"self_or_cls",
".",
"param",
".",
"_TRIGGER",
")",
"for",
"name",
"in",
"watcher",
".",
"parameter_names",
"if",
"(",
"name",
",",
"watcher",
".",
"what",
")",
"in",
"event_dict",
"]",
"with",
"batch_watch",
"(",
"self_",
".",
"self_or_cls",
",",
"run",
"=",
"False",
")",
":",
"if",
"watcher",
".",
"mode",
"==",
"'args'",
":",
"watcher",
".",
"fn",
"(",
"*",
"events",
")",
"else",
":",
"watcher",
".",
"fn",
"(",
"*",
"*",
"{",
"c",
".",
"name",
":",
"c",
".",
"new",
"for",
"c",
"in",
"events",
"}",
")"
] |
Batch call a set of watchers based on the parameter value
settings in kwargs using the queued Event and watcher objects.
|
[
"Batch",
"call",
"a",
"set",
"of",
"watchers",
"based",
"on",
"the",
"parameter",
"value",
"settings",
"in",
"kwargs",
"using",
"the",
"queued",
"Event",
"and",
"watcher",
"objects",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1388-L1409
|
11,864
|
pyviz/param
|
param/parameterized.py
|
Parameters.set_dynamic_time_fn
|
def set_dynamic_time_fn(self_,time_fn,sublistattr=None):
"""
Set time_fn for all Dynamic Parameters of this class or
instance object that are currently being dynamically
generated.
Additionally, sets _Dynamic_time_fn=time_fn on this class or
instance object, so that any future changes to Dynamic
Parmeters can inherit time_fn (e.g. if a Number is changed
from a float to a number generator, the number generator will
inherit time_fn).
If specified, sublistattr is the name of an attribute of this
class or instance that contains an iterable collection of
subobjects on which set_dynamic_time_fn should be called. If
the attribute sublistattr is present on any of the subobjects,
set_dynamic_time_fn() will be called for those, too.
"""
self_or_cls = self_.self_or_cls
self_or_cls._Dynamic_time_fn = time_fn
if isinstance(self_or_cls,type):
a = (None,self_or_cls)
else:
a = (self_or_cls,)
for n,p in self_or_cls.param.objects('existing').items():
if hasattr(p, '_value_is_dynamic'):
if p._value_is_dynamic(*a):
g = self_or_cls.param.get_value_generator(n)
g._Dynamic_time_fn = time_fn
if sublistattr:
try:
sublist = getattr(self_or_cls,sublistattr)
except AttributeError:
sublist = []
for obj in sublist:
obj.param.set_dynamic_time_fn(time_fn,sublistattr)
|
python
|
def set_dynamic_time_fn(self_,time_fn,sublistattr=None):
"""
Set time_fn for all Dynamic Parameters of this class or
instance object that are currently being dynamically
generated.
Additionally, sets _Dynamic_time_fn=time_fn on this class or
instance object, so that any future changes to Dynamic
Parmeters can inherit time_fn (e.g. if a Number is changed
from a float to a number generator, the number generator will
inherit time_fn).
If specified, sublistattr is the name of an attribute of this
class or instance that contains an iterable collection of
subobjects on which set_dynamic_time_fn should be called. If
the attribute sublistattr is present on any of the subobjects,
set_dynamic_time_fn() will be called for those, too.
"""
self_or_cls = self_.self_or_cls
self_or_cls._Dynamic_time_fn = time_fn
if isinstance(self_or_cls,type):
a = (None,self_or_cls)
else:
a = (self_or_cls,)
for n,p in self_or_cls.param.objects('existing').items():
if hasattr(p, '_value_is_dynamic'):
if p._value_is_dynamic(*a):
g = self_or_cls.param.get_value_generator(n)
g._Dynamic_time_fn = time_fn
if sublistattr:
try:
sublist = getattr(self_or_cls,sublistattr)
except AttributeError:
sublist = []
for obj in sublist:
obj.param.set_dynamic_time_fn(time_fn,sublistattr)
|
[
"def",
"set_dynamic_time_fn",
"(",
"self_",
",",
"time_fn",
",",
"sublistattr",
"=",
"None",
")",
":",
"self_or_cls",
"=",
"self_",
".",
"self_or_cls",
"self_or_cls",
".",
"_Dynamic_time_fn",
"=",
"time_fn",
"if",
"isinstance",
"(",
"self_or_cls",
",",
"type",
")",
":",
"a",
"=",
"(",
"None",
",",
"self_or_cls",
")",
"else",
":",
"a",
"=",
"(",
"self_or_cls",
",",
")",
"for",
"n",
",",
"p",
"in",
"self_or_cls",
".",
"param",
".",
"objects",
"(",
"'existing'",
")",
".",
"items",
"(",
")",
":",
"if",
"hasattr",
"(",
"p",
",",
"'_value_is_dynamic'",
")",
":",
"if",
"p",
".",
"_value_is_dynamic",
"(",
"*",
"a",
")",
":",
"g",
"=",
"self_or_cls",
".",
"param",
".",
"get_value_generator",
"(",
"n",
")",
"g",
".",
"_Dynamic_time_fn",
"=",
"time_fn",
"if",
"sublistattr",
":",
"try",
":",
"sublist",
"=",
"getattr",
"(",
"self_or_cls",
",",
"sublistattr",
")",
"except",
"AttributeError",
":",
"sublist",
"=",
"[",
"]",
"for",
"obj",
"in",
"sublist",
":",
"obj",
".",
"param",
".",
"set_dynamic_time_fn",
"(",
"time_fn",
",",
"sublistattr",
")"
] |
Set time_fn for all Dynamic Parameters of this class or
instance object that are currently being dynamically
generated.
Additionally, sets _Dynamic_time_fn=time_fn on this class or
instance object, so that any future changes to Dynamic
Parmeters can inherit time_fn (e.g. if a Number is changed
from a float to a number generator, the number generator will
inherit time_fn).
If specified, sublistattr is the name of an attribute of this
class or instance that contains an iterable collection of
subobjects on which set_dynamic_time_fn should be called. If
the attribute sublistattr is present on any of the subobjects,
set_dynamic_time_fn() will be called for those, too.
|
[
"Set",
"time_fn",
"for",
"all",
"Dynamic",
"Parameters",
"of",
"this",
"class",
"or",
"instance",
"object",
"that",
"are",
"currently",
"being",
"dynamically",
"generated",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1412-L1451
|
11,865
|
pyviz/param
|
param/parameterized.py
|
Parameters.get_param_values
|
def get_param_values(self_,onlychanged=False):
"""
Return a list of name,value pairs for all Parameters of this
object.
When called on an instance with onlychanged set to True, will
only return values that are not equal to the default value
(onlychanged has no effect when called on a class).
"""
self_or_cls = self_.self_or_cls
# CEB: we'd actually like to know whether a value has been
# explicitly set on the instance, but I'm not sure that's easy
# (would need to distinguish instantiation of default from
# user setting of value).
vals = []
for name,val in self_or_cls.param.objects('existing').items():
value = self_or_cls.param.get_value_generator(name)
# (this is pointless for cls)
if not onlychanged or not all_equal(value,val.default):
vals.append((name,value))
vals.sort(key=itemgetter(0))
return vals
|
python
|
def get_param_values(self_,onlychanged=False):
"""
Return a list of name,value pairs for all Parameters of this
object.
When called on an instance with onlychanged set to True, will
only return values that are not equal to the default value
(onlychanged has no effect when called on a class).
"""
self_or_cls = self_.self_or_cls
# CEB: we'd actually like to know whether a value has been
# explicitly set on the instance, but I'm not sure that's easy
# (would need to distinguish instantiation of default from
# user setting of value).
vals = []
for name,val in self_or_cls.param.objects('existing').items():
value = self_or_cls.param.get_value_generator(name)
# (this is pointless for cls)
if not onlychanged or not all_equal(value,val.default):
vals.append((name,value))
vals.sort(key=itemgetter(0))
return vals
|
[
"def",
"get_param_values",
"(",
"self_",
",",
"onlychanged",
"=",
"False",
")",
":",
"self_or_cls",
"=",
"self_",
".",
"self_or_cls",
"# CEB: we'd actually like to know whether a value has been",
"# explicitly set on the instance, but I'm not sure that's easy",
"# (would need to distinguish instantiation of default from",
"# user setting of value).",
"vals",
"=",
"[",
"]",
"for",
"name",
",",
"val",
"in",
"self_or_cls",
".",
"param",
".",
"objects",
"(",
"'existing'",
")",
".",
"items",
"(",
")",
":",
"value",
"=",
"self_or_cls",
".",
"param",
".",
"get_value_generator",
"(",
"name",
")",
"# (this is pointless for cls)",
"if",
"not",
"onlychanged",
"or",
"not",
"all_equal",
"(",
"value",
",",
"val",
".",
"default",
")",
":",
"vals",
".",
"append",
"(",
"(",
"name",
",",
"value",
")",
")",
"vals",
".",
"sort",
"(",
"key",
"=",
"itemgetter",
"(",
"0",
")",
")",
"return",
"vals"
] |
Return a list of name,value pairs for all Parameters of this
object.
When called on an instance with onlychanged set to True, will
only return values that are not equal to the default value
(onlychanged has no effect when called on a class).
|
[
"Return",
"a",
"list",
"of",
"name",
"value",
"pairs",
"for",
"all",
"Parameters",
"of",
"this",
"object",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1453-L1475
|
11,866
|
pyviz/param
|
param/parameterized.py
|
Parameters.force_new_dynamic_value
|
def force_new_dynamic_value(self_, name): # pylint: disable-msg=E0213
"""
Force a new value to be generated for the dynamic attribute
name, and return it.
If name is not dynamic, its current value is returned
(i.e. equivalent to getattr(name).
"""
cls_or_slf = self_.self_or_cls
param_obj = cls_or_slf.param.objects('existing').get(name)
if not param_obj:
return getattr(cls_or_slf, name)
cls, slf = None, None
if isinstance(cls_or_slf,type):
cls = cls_or_slf
else:
slf = cls_or_slf
if not hasattr(param_obj,'_force'):
return param_obj.__get__(slf, cls)
else:
return param_obj._force(slf, cls)
|
python
|
def force_new_dynamic_value(self_, name): # pylint: disable-msg=E0213
"""
Force a new value to be generated for the dynamic attribute
name, and return it.
If name is not dynamic, its current value is returned
(i.e. equivalent to getattr(name).
"""
cls_or_slf = self_.self_or_cls
param_obj = cls_or_slf.param.objects('existing').get(name)
if not param_obj:
return getattr(cls_or_slf, name)
cls, slf = None, None
if isinstance(cls_or_slf,type):
cls = cls_or_slf
else:
slf = cls_or_slf
if not hasattr(param_obj,'_force'):
return param_obj.__get__(slf, cls)
else:
return param_obj._force(slf, cls)
|
[
"def",
"force_new_dynamic_value",
"(",
"self_",
",",
"name",
")",
":",
"# pylint: disable-msg=E0213",
"cls_or_slf",
"=",
"self_",
".",
"self_or_cls",
"param_obj",
"=",
"cls_or_slf",
".",
"param",
".",
"objects",
"(",
"'existing'",
")",
".",
"get",
"(",
"name",
")",
"if",
"not",
"param_obj",
":",
"return",
"getattr",
"(",
"cls_or_slf",
",",
"name",
")",
"cls",
",",
"slf",
"=",
"None",
",",
"None",
"if",
"isinstance",
"(",
"cls_or_slf",
",",
"type",
")",
":",
"cls",
"=",
"cls_or_slf",
"else",
":",
"slf",
"=",
"cls_or_slf",
"if",
"not",
"hasattr",
"(",
"param_obj",
",",
"'_force'",
")",
":",
"return",
"param_obj",
".",
"__get__",
"(",
"slf",
",",
"cls",
")",
"else",
":",
"return",
"param_obj",
".",
"_force",
"(",
"slf",
",",
"cls",
")"
] |
Force a new value to be generated for the dynamic attribute
name, and return it.
If name is not dynamic, its current value is returned
(i.e. equivalent to getattr(name).
|
[
"Force",
"a",
"new",
"value",
"to",
"be",
"generated",
"for",
"the",
"dynamic",
"attribute",
"name",
"and",
"return",
"it",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1478-L1501
|
11,867
|
pyviz/param
|
param/parameterized.py
|
Parameters.get_value_generator
|
def get_value_generator(self_,name): # pylint: disable-msg=E0213
"""
Return the value or value-generating object of the named
attribute.
For most parameters, this is simply the parameter's value
(i.e. the same as getattr()), but Dynamic parameters have
their value-generating object returned.
"""
cls_or_slf = self_.self_or_cls
param_obj = cls_or_slf.param.objects('existing').get(name)
if not param_obj:
value = getattr(cls_or_slf,name)
# CompositeParameter detected by being a Parameter and having 'attribs'
elif hasattr(param_obj,'attribs'):
value = [cls_or_slf.param.get_value_generator(a) for a in param_obj.attribs]
# not a Dynamic Parameter
elif not hasattr(param_obj,'_value_is_dynamic'):
value = getattr(cls_or_slf,name)
# Dynamic Parameter...
else:
internal_name = "_%s_param_value"%name
if hasattr(cls_or_slf,internal_name):
# dealing with object and it's been set on this object
value = getattr(cls_or_slf,internal_name)
else:
# dealing with class or isn't set on the object
value = param_obj.default
return value
|
python
|
def get_value_generator(self_,name): # pylint: disable-msg=E0213
"""
Return the value or value-generating object of the named
attribute.
For most parameters, this is simply the parameter's value
(i.e. the same as getattr()), but Dynamic parameters have
their value-generating object returned.
"""
cls_or_slf = self_.self_or_cls
param_obj = cls_or_slf.param.objects('existing').get(name)
if not param_obj:
value = getattr(cls_or_slf,name)
# CompositeParameter detected by being a Parameter and having 'attribs'
elif hasattr(param_obj,'attribs'):
value = [cls_or_slf.param.get_value_generator(a) for a in param_obj.attribs]
# not a Dynamic Parameter
elif not hasattr(param_obj,'_value_is_dynamic'):
value = getattr(cls_or_slf,name)
# Dynamic Parameter...
else:
internal_name = "_%s_param_value"%name
if hasattr(cls_or_slf,internal_name):
# dealing with object and it's been set on this object
value = getattr(cls_or_slf,internal_name)
else:
# dealing with class or isn't set on the object
value = param_obj.default
return value
|
[
"def",
"get_value_generator",
"(",
"self_",
",",
"name",
")",
":",
"# pylint: disable-msg=E0213",
"cls_or_slf",
"=",
"self_",
".",
"self_or_cls",
"param_obj",
"=",
"cls_or_slf",
".",
"param",
".",
"objects",
"(",
"'existing'",
")",
".",
"get",
"(",
"name",
")",
"if",
"not",
"param_obj",
":",
"value",
"=",
"getattr",
"(",
"cls_or_slf",
",",
"name",
")",
"# CompositeParameter detected by being a Parameter and having 'attribs'",
"elif",
"hasattr",
"(",
"param_obj",
",",
"'attribs'",
")",
":",
"value",
"=",
"[",
"cls_or_slf",
".",
"param",
".",
"get_value_generator",
"(",
"a",
")",
"for",
"a",
"in",
"param_obj",
".",
"attribs",
"]",
"# not a Dynamic Parameter",
"elif",
"not",
"hasattr",
"(",
"param_obj",
",",
"'_value_is_dynamic'",
")",
":",
"value",
"=",
"getattr",
"(",
"cls_or_slf",
",",
"name",
")",
"# Dynamic Parameter...",
"else",
":",
"internal_name",
"=",
"\"_%s_param_value\"",
"%",
"name",
"if",
"hasattr",
"(",
"cls_or_slf",
",",
"internal_name",
")",
":",
"# dealing with object and it's been set on this object",
"value",
"=",
"getattr",
"(",
"cls_or_slf",
",",
"internal_name",
")",
"else",
":",
"# dealing with class or isn't set on the object",
"value",
"=",
"param_obj",
".",
"default",
"return",
"value"
] |
Return the value or value-generating object of the named
attribute.
For most parameters, this is simply the parameter's value
(i.e. the same as getattr()), but Dynamic parameters have
their value-generating object returned.
|
[
"Return",
"the",
"value",
"or",
"value",
"-",
"generating",
"object",
"of",
"the",
"named",
"attribute",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1504-L1537
|
11,868
|
pyviz/param
|
param/parameterized.py
|
Parameters.inspect_value
|
def inspect_value(self_,name): # pylint: disable-msg=E0213
"""
Return the current value of the named attribute without modifying it.
Same as getattr() except for Dynamic parameters, which have their
last generated value returned.
"""
cls_or_slf = self_.self_or_cls
param_obj = cls_or_slf.param.objects('existing').get(name)
if not param_obj:
value = getattr(cls_or_slf,name)
elif hasattr(param_obj,'attribs'):
value = [cls_or_slf.param.inspect_value(a) for a in param_obj.attribs]
elif not hasattr(param_obj,'_inspect'):
value = getattr(cls_or_slf,name)
else:
if isinstance(cls_or_slf,type):
value = param_obj._inspect(None,cls_or_slf)
else:
value = param_obj._inspect(cls_or_slf,None)
return value
|
python
|
def inspect_value(self_,name): # pylint: disable-msg=E0213
"""
Return the current value of the named attribute without modifying it.
Same as getattr() except for Dynamic parameters, which have their
last generated value returned.
"""
cls_or_slf = self_.self_or_cls
param_obj = cls_or_slf.param.objects('existing').get(name)
if not param_obj:
value = getattr(cls_or_slf,name)
elif hasattr(param_obj,'attribs'):
value = [cls_or_slf.param.inspect_value(a) for a in param_obj.attribs]
elif not hasattr(param_obj,'_inspect'):
value = getattr(cls_or_slf,name)
else:
if isinstance(cls_or_slf,type):
value = param_obj._inspect(None,cls_or_slf)
else:
value = param_obj._inspect(cls_or_slf,None)
return value
|
[
"def",
"inspect_value",
"(",
"self_",
",",
"name",
")",
":",
"# pylint: disable-msg=E0213",
"cls_or_slf",
"=",
"self_",
".",
"self_or_cls",
"param_obj",
"=",
"cls_or_slf",
".",
"param",
".",
"objects",
"(",
"'existing'",
")",
".",
"get",
"(",
"name",
")",
"if",
"not",
"param_obj",
":",
"value",
"=",
"getattr",
"(",
"cls_or_slf",
",",
"name",
")",
"elif",
"hasattr",
"(",
"param_obj",
",",
"'attribs'",
")",
":",
"value",
"=",
"[",
"cls_or_slf",
".",
"param",
".",
"inspect_value",
"(",
"a",
")",
"for",
"a",
"in",
"param_obj",
".",
"attribs",
"]",
"elif",
"not",
"hasattr",
"(",
"param_obj",
",",
"'_inspect'",
")",
":",
"value",
"=",
"getattr",
"(",
"cls_or_slf",
",",
"name",
")",
"else",
":",
"if",
"isinstance",
"(",
"cls_or_slf",
",",
"type",
")",
":",
"value",
"=",
"param_obj",
".",
"_inspect",
"(",
"None",
",",
"cls_or_slf",
")",
"else",
":",
"value",
"=",
"param_obj",
".",
"_inspect",
"(",
"cls_or_slf",
",",
"None",
")",
"return",
"value"
] |
Return the current value of the named attribute without modifying it.
Same as getattr() except for Dynamic parameters, which have their
last generated value returned.
|
[
"Return",
"the",
"current",
"value",
"of",
"the",
"named",
"attribute",
"without",
"modifying",
"it",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1539-L1561
|
11,869
|
pyviz/param
|
param/parameterized.py
|
Parameters.outputs
|
def outputs(self_):
"""
Returns a mapping between any declared outputs and a tuple
of the declared Parameter type, the output method, and the
index into the output if multiple outputs are returned.
"""
outputs = {}
for cls in classlist(self_.cls):
for name in dir(cls):
method = getattr(self_.self_or_cls, name)
dinfo = getattr(method, '_dinfo', {})
if 'outputs' not in dinfo:
continue
for override, otype, idx in dinfo['outputs']:
if override is not None:
name = override
outputs[name] = (otype, method, idx)
return outputs
|
python
|
def outputs(self_):
"""
Returns a mapping between any declared outputs and a tuple
of the declared Parameter type, the output method, and the
index into the output if multiple outputs are returned.
"""
outputs = {}
for cls in classlist(self_.cls):
for name in dir(cls):
method = getattr(self_.self_or_cls, name)
dinfo = getattr(method, '_dinfo', {})
if 'outputs' not in dinfo:
continue
for override, otype, idx in dinfo['outputs']:
if override is not None:
name = override
outputs[name] = (otype, method, idx)
return outputs
|
[
"def",
"outputs",
"(",
"self_",
")",
":",
"outputs",
"=",
"{",
"}",
"for",
"cls",
"in",
"classlist",
"(",
"self_",
".",
"cls",
")",
":",
"for",
"name",
"in",
"dir",
"(",
"cls",
")",
":",
"method",
"=",
"getattr",
"(",
"self_",
".",
"self_or_cls",
",",
"name",
")",
"dinfo",
"=",
"getattr",
"(",
"method",
",",
"'_dinfo'",
",",
"{",
"}",
")",
"if",
"'outputs'",
"not",
"in",
"dinfo",
":",
"continue",
"for",
"override",
",",
"otype",
",",
"idx",
"in",
"dinfo",
"[",
"'outputs'",
"]",
":",
"if",
"override",
"is",
"not",
"None",
":",
"name",
"=",
"override",
"outputs",
"[",
"name",
"]",
"=",
"(",
"otype",
",",
"method",
",",
"idx",
")",
"return",
"outputs"
] |
Returns a mapping between any declared outputs and a tuple
of the declared Parameter type, the output method, and the
index into the output if multiple outputs are returned.
|
[
"Returns",
"a",
"mapping",
"between",
"any",
"declared",
"outputs",
"and",
"a",
"tuple",
"of",
"the",
"declared",
"Parameter",
"type",
"the",
"output",
"method",
"and",
"the",
"index",
"into",
"the",
"output",
"if",
"multiple",
"outputs",
"are",
"returned",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1568-L1585
|
11,870
|
pyviz/param
|
param/parameterized.py
|
Parameters.unwatch
|
def unwatch(self_,watcher):
"""
Unwatch watchers set either with watch or watch_values.
"""
try:
self_._watch('remove',watcher)
except:
self_.warning('No such watcher {watcher} to remove.'.format(watcher=watcher))
|
python
|
def unwatch(self_,watcher):
"""
Unwatch watchers set either with watch or watch_values.
"""
try:
self_._watch('remove',watcher)
except:
self_.warning('No such watcher {watcher} to remove.'.format(watcher=watcher))
|
[
"def",
"unwatch",
"(",
"self_",
",",
"watcher",
")",
":",
"try",
":",
"self_",
".",
"_watch",
"(",
"'remove'",
",",
"watcher",
")",
"except",
":",
"self_",
".",
"warning",
"(",
"'No such watcher {watcher} to remove.'",
".",
"format",
"(",
"watcher",
"=",
"watcher",
")",
")"
] |
Unwatch watchers set either with watch or watch_values.
|
[
"Unwatch",
"watchers",
"set",
"either",
"with",
"watch",
"or",
"watch_values",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1645-L1652
|
11,871
|
pyviz/param
|
param/parameterized.py
|
Parameters.print_param_values
|
def print_param_values(self_):
"""Print the values of all this object's Parameters."""
self = self_.self
for name,val in self.param.get_param_values():
print('%s.%s = %s' % (self.name,name,val))
|
python
|
def print_param_values(self_):
"""Print the values of all this object's Parameters."""
self = self_.self
for name,val in self.param.get_param_values():
print('%s.%s = %s' % (self.name,name,val))
|
[
"def",
"print_param_values",
"(",
"self_",
")",
":",
"self",
"=",
"self_",
".",
"self",
"for",
"name",
",",
"val",
"in",
"self",
".",
"param",
".",
"get_param_values",
"(",
")",
":",
"print",
"(",
"'%s.%s = %s'",
"%",
"(",
"self",
".",
"name",
",",
"name",
",",
"val",
")",
")"
] |
Print the values of all this object's Parameters.
|
[
"Print",
"the",
"values",
"of",
"all",
"this",
"object",
"s",
"Parameters",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1706-L1710
|
11,872
|
pyviz/param
|
param/parameterized.py
|
Parameters.warning
|
def warning(self_, msg,*args,**kw):
"""
Print msg merged with args as a warning, unless module variable
warnings_as_exceptions is True, then raise an Exception
containing the arguments.
See Python's logging module for details of message formatting.
"""
if not warnings_as_exceptions:
global warning_count
warning_count+=1
self_.__db_print(WARNING,msg,*args,**kw)
else:
raise Exception("Warning: " + msg % args)
|
python
|
def warning(self_, msg,*args,**kw):
"""
Print msg merged with args as a warning, unless module variable
warnings_as_exceptions is True, then raise an Exception
containing the arguments.
See Python's logging module for details of message formatting.
"""
if not warnings_as_exceptions:
global warning_count
warning_count+=1
self_.__db_print(WARNING,msg,*args,**kw)
else:
raise Exception("Warning: " + msg % args)
|
[
"def",
"warning",
"(",
"self_",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"if",
"not",
"warnings_as_exceptions",
":",
"global",
"warning_count",
"warning_count",
"+=",
"1",
"self_",
".",
"__db_print",
"(",
"WARNING",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
"else",
":",
"raise",
"Exception",
"(",
"\"Warning: \"",
"+",
"msg",
"%",
"args",
")"
] |
Print msg merged with args as a warning, unless module variable
warnings_as_exceptions is True, then raise an Exception
containing the arguments.
See Python's logging module for details of message formatting.
|
[
"Print",
"msg",
"merged",
"with",
"args",
"as",
"a",
"warning",
"unless",
"module",
"variable",
"warnings_as_exceptions",
"is",
"True",
"then",
"raise",
"an",
"Exception",
"containing",
"the",
"arguments",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1712-L1725
|
11,873
|
pyviz/param
|
param/parameterized.py
|
Parameters.message
|
def message(self_,msg,*args,**kw):
"""
Print msg merged with args as a message.
See Python's logging module for details of message formatting.
"""
self_.__db_print(INFO,msg,*args,**kw)
|
python
|
def message(self_,msg,*args,**kw):
"""
Print msg merged with args as a message.
See Python's logging module for details of message formatting.
"""
self_.__db_print(INFO,msg,*args,**kw)
|
[
"def",
"message",
"(",
"self_",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"self_",
".",
"__db_print",
"(",
"INFO",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")"
] |
Print msg merged with args as a message.
See Python's logging module for details of message formatting.
|
[
"Print",
"msg",
"merged",
"with",
"args",
"as",
"a",
"message",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1727-L1733
|
11,874
|
pyviz/param
|
param/parameterized.py
|
Parameters.verbose
|
def verbose(self_,msg,*args,**kw):
"""
Print msg merged with args as a verbose message.
See Python's logging module for details of message formatting.
"""
self_.__db_print(VERBOSE,msg,*args,**kw)
|
python
|
def verbose(self_,msg,*args,**kw):
"""
Print msg merged with args as a verbose message.
See Python's logging module for details of message formatting.
"""
self_.__db_print(VERBOSE,msg,*args,**kw)
|
[
"def",
"verbose",
"(",
"self_",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"self_",
".",
"__db_print",
"(",
"VERBOSE",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")"
] |
Print msg merged with args as a verbose message.
See Python's logging module for details of message formatting.
|
[
"Print",
"msg",
"merged",
"with",
"args",
"as",
"a",
"verbose",
"message",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1735-L1741
|
11,875
|
pyviz/param
|
param/parameterized.py
|
Parameters.debug
|
def debug(self_,msg,*args,**kw):
"""
Print msg merged with args as a debugging statement.
See Python's logging module for details of message formatting.
"""
self_.__db_print(DEBUG,msg,*args,**kw)
|
python
|
def debug(self_,msg,*args,**kw):
"""
Print msg merged with args as a debugging statement.
See Python's logging module for details of message formatting.
"""
self_.__db_print(DEBUG,msg,*args,**kw)
|
[
"def",
"debug",
"(",
"self_",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"self_",
".",
"__db_print",
"(",
"DEBUG",
",",
"msg",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")"
] |
Print msg merged with args as a debugging statement.
See Python's logging module for details of message formatting.
|
[
"Print",
"msg",
"merged",
"with",
"args",
"as",
"a",
"debugging",
"statement",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1743-L1749
|
11,876
|
pyviz/param
|
param/parameterized.py
|
ParameterizedMetaclass.__class_docstring_signature
|
def __class_docstring_signature(mcs, max_repr_len=15):
"""
Autogenerate a keyword signature in the class docstring for
all available parameters. This is particularly useful in the
IPython Notebook as IPython will parse this signature to allow
tab-completion of keywords.
max_repr_len: Maximum length (in characters) of value reprs.
"""
processed_kws, keyword_groups = set(), []
for cls in reversed(mcs.mro()):
keyword_group = []
for (k,v) in sorted(cls.__dict__.items()):
if isinstance(v, Parameter) and k not in processed_kws:
param_type = v.__class__.__name__
keyword_group.append("%s=%s" % (k, param_type))
processed_kws.add(k)
keyword_groups.append(keyword_group)
keywords = [el for grp in reversed(keyword_groups) for el in grp]
class_docstr = "\n"+mcs.__doc__ if mcs.__doc__ else ''
signature = "params(%s)" % (", ".join(keywords))
description = param_pager(mcs) if (docstring_describe_params and param_pager) else ''
mcs.__doc__ = signature + class_docstr + '\n' + description
|
python
|
def __class_docstring_signature(mcs, max_repr_len=15):
"""
Autogenerate a keyword signature in the class docstring for
all available parameters. This is particularly useful in the
IPython Notebook as IPython will parse this signature to allow
tab-completion of keywords.
max_repr_len: Maximum length (in characters) of value reprs.
"""
processed_kws, keyword_groups = set(), []
for cls in reversed(mcs.mro()):
keyword_group = []
for (k,v) in sorted(cls.__dict__.items()):
if isinstance(v, Parameter) and k not in processed_kws:
param_type = v.__class__.__name__
keyword_group.append("%s=%s" % (k, param_type))
processed_kws.add(k)
keyword_groups.append(keyword_group)
keywords = [el for grp in reversed(keyword_groups) for el in grp]
class_docstr = "\n"+mcs.__doc__ if mcs.__doc__ else ''
signature = "params(%s)" % (", ".join(keywords))
description = param_pager(mcs) if (docstring_describe_params and param_pager) else ''
mcs.__doc__ = signature + class_docstr + '\n' + description
|
[
"def",
"__class_docstring_signature",
"(",
"mcs",
",",
"max_repr_len",
"=",
"15",
")",
":",
"processed_kws",
",",
"keyword_groups",
"=",
"set",
"(",
")",
",",
"[",
"]",
"for",
"cls",
"in",
"reversed",
"(",
"mcs",
".",
"mro",
"(",
")",
")",
":",
"keyword_group",
"=",
"[",
"]",
"for",
"(",
"k",
",",
"v",
")",
"in",
"sorted",
"(",
"cls",
".",
"__dict__",
".",
"items",
"(",
")",
")",
":",
"if",
"isinstance",
"(",
"v",
",",
"Parameter",
")",
"and",
"k",
"not",
"in",
"processed_kws",
":",
"param_type",
"=",
"v",
".",
"__class__",
".",
"__name__",
"keyword_group",
".",
"append",
"(",
"\"%s=%s\"",
"%",
"(",
"k",
",",
"param_type",
")",
")",
"processed_kws",
".",
"add",
"(",
"k",
")",
"keyword_groups",
".",
"append",
"(",
"keyword_group",
")",
"keywords",
"=",
"[",
"el",
"for",
"grp",
"in",
"reversed",
"(",
"keyword_groups",
")",
"for",
"el",
"in",
"grp",
"]",
"class_docstr",
"=",
"\"\\n\"",
"+",
"mcs",
".",
"__doc__",
"if",
"mcs",
".",
"__doc__",
"else",
"''",
"signature",
"=",
"\"params(%s)\"",
"%",
"(",
"\", \"",
".",
"join",
"(",
"keywords",
")",
")",
"description",
"=",
"param_pager",
"(",
"mcs",
")",
"if",
"(",
"docstring_describe_params",
"and",
"param_pager",
")",
"else",
"''",
"mcs",
".",
"__doc__",
"=",
"signature",
"+",
"class_docstr",
"+",
"'\\n'",
"+",
"description"
] |
Autogenerate a keyword signature in the class docstring for
all available parameters. This is particularly useful in the
IPython Notebook as IPython will parse this signature to allow
tab-completion of keywords.
max_repr_len: Maximum length (in characters) of value reprs.
|
[
"Autogenerate",
"a",
"keyword",
"signature",
"in",
"the",
"class",
"docstring",
"for",
"all",
"available",
"parameters",
".",
"This",
"is",
"particularly",
"useful",
"in",
"the",
"IPython",
"Notebook",
"as",
"IPython",
"will",
"parse",
"this",
"signature",
"to",
"allow",
"tab",
"-",
"completion",
"of",
"keywords",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1830-L1853
|
11,877
|
pyviz/param
|
param/parameterized.py
|
ParameterizedMetaclass.__param_inheritance
|
def __param_inheritance(mcs,param_name,param):
"""
Look for Parameter values in superclasses of this
Parameterized class.
Ordinarily, when a Python object is instantiated, attributes
not given values in the constructor will inherit the value
given in the object's class, or in its superclasses. For
Parameters owned by Parameterized classes, we have implemented
an additional level of default lookup, should this ordinary
lookup return only None.
In such a case, i.e. when no non-None value was found for a
Parameter by the usual inheritance mechanisms, we explicitly
look for Parameters with the same name in superclasses of this
Parameterized class, and use the first such value that we
find.
The goal is to be able to set the default value (or other
slots) of a Parameter within a Parameterized class, just as we
can set values for non-Parameter objects in Parameterized
classes, and have the values inherited through the
Parameterized hierarchy as usual.
Note that instantiate is handled differently: if there is a
parameter with the same name in one of the superclasses with
instantiate set to True, this parameter will inherit
instatiate=True.
"""
# get all relevant slots (i.e. slots defined in all
# superclasses of this parameter)
slots = {}
for p_class in classlist(type(param))[1::]:
slots.update(dict.fromkeys(p_class.__slots__))
# note for some eventual future: python 3.6+ descriptors grew
# __set_name__, which could replace this and _set_names
setattr(param,'owner',mcs)
del slots['owner']
# backwards compatibility (see Composite parameter)
if 'objtype' in slots:
setattr(param,'objtype',mcs)
del slots['objtype']
# instantiate is handled specially
for superclass in classlist(mcs)[::-1]:
super_param = superclass.__dict__.get(param_name)
if isinstance(super_param, Parameter) and super_param.instantiate is True:
param.instantiate=True
del slots['instantiate']
for slot in slots.keys():
superclasses = iter(classlist(mcs)[::-1])
# Search up the hierarchy until param.slot (which has to
# be obtained using getattr(param,slot)) is not None, or
# we run out of classes to search.
while getattr(param,slot) is None:
try:
param_super_class = next(superclasses)
except StopIteration:
break
new_param = param_super_class.__dict__.get(param_name)
if new_param is not None and hasattr(new_param,slot):
# (slot might not be there because could be a more
# general type of Parameter)
new_value = getattr(new_param,slot)
setattr(param,slot,new_value)
|
python
|
def __param_inheritance(mcs,param_name,param):
"""
Look for Parameter values in superclasses of this
Parameterized class.
Ordinarily, when a Python object is instantiated, attributes
not given values in the constructor will inherit the value
given in the object's class, or in its superclasses. For
Parameters owned by Parameterized classes, we have implemented
an additional level of default lookup, should this ordinary
lookup return only None.
In such a case, i.e. when no non-None value was found for a
Parameter by the usual inheritance mechanisms, we explicitly
look for Parameters with the same name in superclasses of this
Parameterized class, and use the first such value that we
find.
The goal is to be able to set the default value (or other
slots) of a Parameter within a Parameterized class, just as we
can set values for non-Parameter objects in Parameterized
classes, and have the values inherited through the
Parameterized hierarchy as usual.
Note that instantiate is handled differently: if there is a
parameter with the same name in one of the superclasses with
instantiate set to True, this parameter will inherit
instatiate=True.
"""
# get all relevant slots (i.e. slots defined in all
# superclasses of this parameter)
slots = {}
for p_class in classlist(type(param))[1::]:
slots.update(dict.fromkeys(p_class.__slots__))
# note for some eventual future: python 3.6+ descriptors grew
# __set_name__, which could replace this and _set_names
setattr(param,'owner',mcs)
del slots['owner']
# backwards compatibility (see Composite parameter)
if 'objtype' in slots:
setattr(param,'objtype',mcs)
del slots['objtype']
# instantiate is handled specially
for superclass in classlist(mcs)[::-1]:
super_param = superclass.__dict__.get(param_name)
if isinstance(super_param, Parameter) and super_param.instantiate is True:
param.instantiate=True
del slots['instantiate']
for slot in slots.keys():
superclasses = iter(classlist(mcs)[::-1])
# Search up the hierarchy until param.slot (which has to
# be obtained using getattr(param,slot)) is not None, or
# we run out of classes to search.
while getattr(param,slot) is None:
try:
param_super_class = next(superclasses)
except StopIteration:
break
new_param = param_super_class.__dict__.get(param_name)
if new_param is not None and hasattr(new_param,slot):
# (slot might not be there because could be a more
# general type of Parameter)
new_value = getattr(new_param,slot)
setattr(param,slot,new_value)
|
[
"def",
"__param_inheritance",
"(",
"mcs",
",",
"param_name",
",",
"param",
")",
":",
"# get all relevant slots (i.e. slots defined in all",
"# superclasses of this parameter)",
"slots",
"=",
"{",
"}",
"for",
"p_class",
"in",
"classlist",
"(",
"type",
"(",
"param",
")",
")",
"[",
"1",
":",
":",
"]",
":",
"slots",
".",
"update",
"(",
"dict",
".",
"fromkeys",
"(",
"p_class",
".",
"__slots__",
")",
")",
"# note for some eventual future: python 3.6+ descriptors grew",
"# __set_name__, which could replace this and _set_names",
"setattr",
"(",
"param",
",",
"'owner'",
",",
"mcs",
")",
"del",
"slots",
"[",
"'owner'",
"]",
"# backwards compatibility (see Composite parameter)",
"if",
"'objtype'",
"in",
"slots",
":",
"setattr",
"(",
"param",
",",
"'objtype'",
",",
"mcs",
")",
"del",
"slots",
"[",
"'objtype'",
"]",
"# instantiate is handled specially",
"for",
"superclass",
"in",
"classlist",
"(",
"mcs",
")",
"[",
":",
":",
"-",
"1",
"]",
":",
"super_param",
"=",
"superclass",
".",
"__dict__",
".",
"get",
"(",
"param_name",
")",
"if",
"isinstance",
"(",
"super_param",
",",
"Parameter",
")",
"and",
"super_param",
".",
"instantiate",
"is",
"True",
":",
"param",
".",
"instantiate",
"=",
"True",
"del",
"slots",
"[",
"'instantiate'",
"]",
"for",
"slot",
"in",
"slots",
".",
"keys",
"(",
")",
":",
"superclasses",
"=",
"iter",
"(",
"classlist",
"(",
"mcs",
")",
"[",
":",
":",
"-",
"1",
"]",
")",
"# Search up the hierarchy until param.slot (which has to",
"# be obtained using getattr(param,slot)) is not None, or",
"# we run out of classes to search.",
"while",
"getattr",
"(",
"param",
",",
"slot",
")",
"is",
"None",
":",
"try",
":",
"param_super_class",
"=",
"next",
"(",
"superclasses",
")",
"except",
"StopIteration",
":",
"break",
"new_param",
"=",
"param_super_class",
".",
"__dict__",
".",
"get",
"(",
"param_name",
")",
"if",
"new_param",
"is",
"not",
"None",
"and",
"hasattr",
"(",
"new_param",
",",
"slot",
")",
":",
"# (slot might not be there because could be a more",
"# general type of Parameter)",
"new_value",
"=",
"getattr",
"(",
"new_param",
",",
"slot",
")",
"setattr",
"(",
"param",
",",
"slot",
",",
"new_value",
")"
] |
Look for Parameter values in superclasses of this
Parameterized class.
Ordinarily, when a Python object is instantiated, attributes
not given values in the constructor will inherit the value
given in the object's class, or in its superclasses. For
Parameters owned by Parameterized classes, we have implemented
an additional level of default lookup, should this ordinary
lookup return only None.
In such a case, i.e. when no non-None value was found for a
Parameter by the usual inheritance mechanisms, we explicitly
look for Parameters with the same name in superclasses of this
Parameterized class, and use the first such value that we
find.
The goal is to be able to set the default value (or other
slots) of a Parameter within a Parameterized class, just as we
can set values for non-Parameter objects in Parameterized
classes, and have the values inherited through the
Parameterized hierarchy as usual.
Note that instantiate is handled differently: if there is a
parameter with the same name in one of the superclasses with
instantiate set to True, this parameter will inherit
instatiate=True.
|
[
"Look",
"for",
"Parameter",
"values",
"in",
"superclasses",
"of",
"this",
"Parameterized",
"class",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1940-L2011
|
11,878
|
pyviz/param
|
param/parameterized.py
|
ParamOverrides._check_params
|
def _check_params(self,params):
"""
Print a warning if params contains something that is not a
Parameter of the overridden object.
"""
overridden_object_params = list(self._overridden.param)
for item in params:
if item not in overridden_object_params:
self.param.warning("'%s' will be ignored (not a Parameter).",item)
|
python
|
def _check_params(self,params):
"""
Print a warning if params contains something that is not a
Parameter of the overridden object.
"""
overridden_object_params = list(self._overridden.param)
for item in params:
if item not in overridden_object_params:
self.param.warning("'%s' will be ignored (not a Parameter).",item)
|
[
"def",
"_check_params",
"(",
"self",
",",
"params",
")",
":",
"overridden_object_params",
"=",
"list",
"(",
"self",
".",
"_overridden",
".",
"param",
")",
"for",
"item",
"in",
"params",
":",
"if",
"item",
"not",
"in",
"overridden_object_params",
":",
"self",
".",
"param",
".",
"warning",
"(",
"\"'%s' will be ignored (not a Parameter).\"",
",",
"item",
")"
] |
Print a warning if params contains something that is not a
Parameter of the overridden object.
|
[
"Print",
"a",
"warning",
"if",
"params",
"contains",
"something",
"that",
"is",
"not",
"a",
"Parameter",
"of",
"the",
"overridden",
"object",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2653-L2661
|
11,879
|
pyviz/param
|
param/parameterized.py
|
ParamOverrides._extract_extra_keywords
|
def _extract_extra_keywords(self,params):
"""
Return any items in params that are not also
parameters of the overridden object.
"""
extra_keywords = {}
overridden_object_params = list(self._overridden.param)
for name, val in params.items():
if name not in overridden_object_params:
extra_keywords[name]=val
# CEBALERT: should we remove name from params
# (i.e. del params[name]) so that it's only available
# via extra_keywords()?
return extra_keywords
|
python
|
def _extract_extra_keywords(self,params):
"""
Return any items in params that are not also
parameters of the overridden object.
"""
extra_keywords = {}
overridden_object_params = list(self._overridden.param)
for name, val in params.items():
if name not in overridden_object_params:
extra_keywords[name]=val
# CEBALERT: should we remove name from params
# (i.e. del params[name]) so that it's only available
# via extra_keywords()?
return extra_keywords
|
[
"def",
"_extract_extra_keywords",
"(",
"self",
",",
"params",
")",
":",
"extra_keywords",
"=",
"{",
"}",
"overridden_object_params",
"=",
"list",
"(",
"self",
".",
"_overridden",
".",
"param",
")",
"for",
"name",
",",
"val",
"in",
"params",
".",
"items",
"(",
")",
":",
"if",
"name",
"not",
"in",
"overridden_object_params",
":",
"extra_keywords",
"[",
"name",
"]",
"=",
"val",
"# CEBALERT: should we remove name from params",
"# (i.e. del params[name]) so that it's only available",
"# via extra_keywords()?",
"return",
"extra_keywords"
] |
Return any items in params that are not also
parameters of the overridden object.
|
[
"Return",
"any",
"items",
"in",
"params",
"that",
"are",
"not",
"also",
"parameters",
"of",
"the",
"overridden",
"object",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2663-L2676
|
11,880
|
pyviz/param
|
param/parameterized.py
|
ParameterizedFunction.instance
|
def instance(self_or_cls,**params):
"""
Return an instance of this class, copying parameters from any
existing instance provided.
"""
if isinstance (self_or_cls,ParameterizedMetaclass):
cls = self_or_cls
else:
p = params
params = dict(self_or_cls.get_param_values())
params.update(p)
params.pop('name')
cls = self_or_cls.__class__
inst=Parameterized.__new__(cls)
Parameterized.__init__(inst,**params)
if 'name' in params: inst.__name__ = params['name']
else: inst.__name__ = self_or_cls.name
return inst
|
python
|
def instance(self_or_cls,**params):
"""
Return an instance of this class, copying parameters from any
existing instance provided.
"""
if isinstance (self_or_cls,ParameterizedMetaclass):
cls = self_or_cls
else:
p = params
params = dict(self_or_cls.get_param_values())
params.update(p)
params.pop('name')
cls = self_or_cls.__class__
inst=Parameterized.__new__(cls)
Parameterized.__init__(inst,**params)
if 'name' in params: inst.__name__ = params['name']
else: inst.__name__ = self_or_cls.name
return inst
|
[
"def",
"instance",
"(",
"self_or_cls",
",",
"*",
"*",
"params",
")",
":",
"if",
"isinstance",
"(",
"self_or_cls",
",",
"ParameterizedMetaclass",
")",
":",
"cls",
"=",
"self_or_cls",
"else",
":",
"p",
"=",
"params",
"params",
"=",
"dict",
"(",
"self_or_cls",
".",
"get_param_values",
"(",
")",
")",
"params",
".",
"update",
"(",
"p",
")",
"params",
".",
"pop",
"(",
"'name'",
")",
"cls",
"=",
"self_or_cls",
".",
"__class__",
"inst",
"=",
"Parameterized",
".",
"__new__",
"(",
"cls",
")",
"Parameterized",
".",
"__init__",
"(",
"inst",
",",
"*",
"*",
"params",
")",
"if",
"'name'",
"in",
"params",
":",
"inst",
".",
"__name__",
"=",
"params",
"[",
"'name'",
"]",
"else",
":",
"inst",
".",
"__name__",
"=",
"self_or_cls",
".",
"name",
"return",
"inst"
] |
Return an instance of this class, copying parameters from any
existing instance provided.
|
[
"Return",
"an",
"instance",
"of",
"this",
"class",
"copying",
"parameters",
"from",
"any",
"existing",
"instance",
"provided",
"."
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2702-L2721
|
11,881
|
pyviz/param
|
param/parameterized.py
|
ParameterizedFunction.script_repr
|
def script_repr(self,imports=[],prefix=" "):
"""
Same as Parameterized.script_repr, except that X.classname(Y
is replaced with X.classname.instance(Y
"""
return self.pprint(imports,prefix,unknown_value='',qualify=True,
separator="\n")
|
python
|
def script_repr(self,imports=[],prefix=" "):
"""
Same as Parameterized.script_repr, except that X.classname(Y
is replaced with X.classname.instance(Y
"""
return self.pprint(imports,prefix,unknown_value='',qualify=True,
separator="\n")
|
[
"def",
"script_repr",
"(",
"self",
",",
"imports",
"=",
"[",
"]",
",",
"prefix",
"=",
"\" \"",
")",
":",
"return",
"self",
".",
"pprint",
"(",
"imports",
",",
"prefix",
",",
"unknown_value",
"=",
"''",
",",
"qualify",
"=",
"True",
",",
"separator",
"=",
"\"\\n\"",
")"
] |
Same as Parameterized.script_repr, except that X.classname(Y
is replaced with X.classname.instance(Y
|
[
"Same",
"as",
"Parameterized",
".",
"script_repr",
"except",
"that",
"X",
".",
"classname",
"(",
"Y",
"is",
"replaced",
"with",
"X",
".",
"classname",
".",
"instance",
"(",
"Y"
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2742-L2748
|
11,882
|
pyviz/param
|
param/parameterized.py
|
ParameterizedFunction.pprint
|
def pprint(self, imports=None, prefix="\n ",unknown_value='<?>',
qualify=False, separator=""):
"""
Same as Parameterized.pprint, except that X.classname(Y
is replaced with X.classname.instance(Y
"""
r = Parameterized.pprint(self,imports,prefix,
unknown_value=unknown_value,
qualify=qualify,separator=separator)
classname=self.__class__.__name__
return r.replace(".%s("%classname,".%s.instance("%classname)
|
python
|
def pprint(self, imports=None, prefix="\n ",unknown_value='<?>',
qualify=False, separator=""):
"""
Same as Parameterized.pprint, except that X.classname(Y
is replaced with X.classname.instance(Y
"""
r = Parameterized.pprint(self,imports,prefix,
unknown_value=unknown_value,
qualify=qualify,separator=separator)
classname=self.__class__.__name__
return r.replace(".%s("%classname,".%s.instance("%classname)
|
[
"def",
"pprint",
"(",
"self",
",",
"imports",
"=",
"None",
",",
"prefix",
"=",
"\"\\n \"",
",",
"unknown_value",
"=",
"'<?>'",
",",
"qualify",
"=",
"False",
",",
"separator",
"=",
"\"\"",
")",
":",
"r",
"=",
"Parameterized",
".",
"pprint",
"(",
"self",
",",
"imports",
",",
"prefix",
",",
"unknown_value",
"=",
"unknown_value",
",",
"qualify",
"=",
"qualify",
",",
"separator",
"=",
"separator",
")",
"classname",
"=",
"self",
".",
"__class__",
".",
"__name__",
"return",
"r",
".",
"replace",
"(",
"\".%s(\"",
"%",
"classname",
",",
"\".%s.instance(\"",
"%",
"classname",
")"
] |
Same as Parameterized.pprint, except that X.classname(Y
is replaced with X.classname.instance(Y
|
[
"Same",
"as",
"Parameterized",
".",
"pprint",
"except",
"that",
"X",
".",
"classname",
"(",
"Y",
"is",
"replaced",
"with",
"X",
".",
"classname",
".",
"instance",
"(",
"Y"
] |
8f0dafa78defa883247b40635f96cc6d5c1b3481
|
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2751-L2761
|
11,883
|
sass/libsass-python
|
sassutils/builder.py
|
Manifest.resolve_filename
|
def resolve_filename(self, package_dir, filename):
"""Gets a proper full relative path of Sass source and
CSS source that will be generated, according to ``package_dir``
and ``filename``.
:param package_dir: the path of package directory
:type package_dir: :class:`str`, :class:`basestring`
:param filename: the filename of Sass/SCSS source to compile
:type filename: :class:`str`, :class:`basestring`
:returns: a pair of (sass, css) path
:rtype: :class:`tuple`
"""
sass_path = os.path.join(package_dir, self.sass_path, filename)
if self.strip_extension:
filename, _ = os.path.splitext(filename)
css_filename = filename + '.css'
css_path = os.path.join(package_dir, self.css_path, css_filename)
return sass_path, css_path
|
python
|
def resolve_filename(self, package_dir, filename):
"""Gets a proper full relative path of Sass source and
CSS source that will be generated, according to ``package_dir``
and ``filename``.
:param package_dir: the path of package directory
:type package_dir: :class:`str`, :class:`basestring`
:param filename: the filename of Sass/SCSS source to compile
:type filename: :class:`str`, :class:`basestring`
:returns: a pair of (sass, css) path
:rtype: :class:`tuple`
"""
sass_path = os.path.join(package_dir, self.sass_path, filename)
if self.strip_extension:
filename, _ = os.path.splitext(filename)
css_filename = filename + '.css'
css_path = os.path.join(package_dir, self.css_path, css_filename)
return sass_path, css_path
|
[
"def",
"resolve_filename",
"(",
"self",
",",
"package_dir",
",",
"filename",
")",
":",
"sass_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"package_dir",
",",
"self",
".",
"sass_path",
",",
"filename",
")",
"if",
"self",
".",
"strip_extension",
":",
"filename",
",",
"_",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"filename",
")",
"css_filename",
"=",
"filename",
"+",
"'.css'",
"css_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"package_dir",
",",
"self",
".",
"css_path",
",",
"css_filename",
")",
"return",
"sass_path",
",",
"css_path"
] |
Gets a proper full relative path of Sass source and
CSS source that will be generated, according to ``package_dir``
and ``filename``.
:param package_dir: the path of package directory
:type package_dir: :class:`str`, :class:`basestring`
:param filename: the filename of Sass/SCSS source to compile
:type filename: :class:`str`, :class:`basestring`
:returns: a pair of (sass, css) path
:rtype: :class:`tuple`
|
[
"Gets",
"a",
"proper",
"full",
"relative",
"path",
"of",
"Sass",
"source",
"and",
"CSS",
"source",
"that",
"will",
"be",
"generated",
"according",
"to",
"package_dir",
"and",
"filename",
"."
] |
fde5b18bc761f0253e71685ee5489e4beb8a403e
|
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sassutils/builder.py#L181-L199
|
11,884
|
sass/libsass-python
|
sassutils/builder.py
|
Manifest.unresolve_filename
|
def unresolve_filename(self, package_dir, filename):
"""Retrieves the probable source path from the output filename. Pass
in a .css path to get out a .scss path.
:param package_dir: the path of the package directory
:type package_dir: :class:`str`
:param filename: the css filename
:type filename: :class:`str`
:returns: the scss filename
:rtype: :class:`str`
"""
filename, _ = os.path.splitext(filename)
if self.strip_extension:
for ext in ('.scss', '.sass'):
test_path = os.path.join(
package_dir, self.sass_path, filename + ext,
)
if os.path.exists(test_path):
return filename + ext
else: # file not found, let it error with `.scss` extension
return filename + '.scss'
else:
return filename
|
python
|
def unresolve_filename(self, package_dir, filename):
"""Retrieves the probable source path from the output filename. Pass
in a .css path to get out a .scss path.
:param package_dir: the path of the package directory
:type package_dir: :class:`str`
:param filename: the css filename
:type filename: :class:`str`
:returns: the scss filename
:rtype: :class:`str`
"""
filename, _ = os.path.splitext(filename)
if self.strip_extension:
for ext in ('.scss', '.sass'):
test_path = os.path.join(
package_dir, self.sass_path, filename + ext,
)
if os.path.exists(test_path):
return filename + ext
else: # file not found, let it error with `.scss` extension
return filename + '.scss'
else:
return filename
|
[
"def",
"unresolve_filename",
"(",
"self",
",",
"package_dir",
",",
"filename",
")",
":",
"filename",
",",
"_",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"filename",
")",
"if",
"self",
".",
"strip_extension",
":",
"for",
"ext",
"in",
"(",
"'.scss'",
",",
"'.sass'",
")",
":",
"test_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"package_dir",
",",
"self",
".",
"sass_path",
",",
"filename",
"+",
"ext",
",",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"test_path",
")",
":",
"return",
"filename",
"+",
"ext",
"else",
":",
"# file not found, let it error with `.scss` extension",
"return",
"filename",
"+",
"'.scss'",
"else",
":",
"return",
"filename"
] |
Retrieves the probable source path from the output filename. Pass
in a .css path to get out a .scss path.
:param package_dir: the path of the package directory
:type package_dir: :class:`str`
:param filename: the css filename
:type filename: :class:`str`
:returns: the scss filename
:rtype: :class:`str`
|
[
"Retrieves",
"the",
"probable",
"source",
"path",
"from",
"the",
"output",
"filename",
".",
"Pass",
"in",
"a",
".",
"css",
"path",
"to",
"get",
"out",
"a",
".",
"scss",
"path",
"."
] |
fde5b18bc761f0253e71685ee5489e4beb8a403e
|
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sassutils/builder.py#L201-L223
|
11,885
|
sass/libsass-python
|
sass.py
|
_validate_importers
|
def _validate_importers(importers):
"""Validates the importers and decorates the callables with our output
formatter.
"""
# They could have no importers, that's chill
if importers is None:
return None
def _to_importer(priority, func):
assert isinstance(priority, int), priority
assert callable(func), func
return (priority, _importer_callback_wrapper(func))
# Our code assumes tuple of tuples
return tuple(_to_importer(priority, func) for priority, func in importers)
|
python
|
def _validate_importers(importers):
"""Validates the importers and decorates the callables with our output
formatter.
"""
# They could have no importers, that's chill
if importers is None:
return None
def _to_importer(priority, func):
assert isinstance(priority, int), priority
assert callable(func), func
return (priority, _importer_callback_wrapper(func))
# Our code assumes tuple of tuples
return tuple(_to_importer(priority, func) for priority, func in importers)
|
[
"def",
"_validate_importers",
"(",
"importers",
")",
":",
"# They could have no importers, that's chill",
"if",
"importers",
"is",
"None",
":",
"return",
"None",
"def",
"_to_importer",
"(",
"priority",
",",
"func",
")",
":",
"assert",
"isinstance",
"(",
"priority",
",",
"int",
")",
",",
"priority",
"assert",
"callable",
"(",
"func",
")",
",",
"func",
"return",
"(",
"priority",
",",
"_importer_callback_wrapper",
"(",
"func",
")",
")",
"# Our code assumes tuple of tuples",
"return",
"tuple",
"(",
"_to_importer",
"(",
"priority",
",",
"func",
")",
"for",
"priority",
",",
"func",
"in",
"importers",
")"
] |
Validates the importers and decorates the callables with our output
formatter.
|
[
"Validates",
"the",
"importers",
"and",
"decorates",
"the",
"callables",
"with",
"our",
"output",
"formatter",
"."
] |
fde5b18bc761f0253e71685ee5489e4beb8a403e
|
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sass.py#L218-L232
|
11,886
|
sass/libsass-python
|
sass.py
|
and_join
|
def and_join(strings):
"""Join the given ``strings`` by commas with last `' and '` conjuction.
>>> and_join(['Korea', 'Japan', 'China', 'Taiwan'])
'Korea, Japan, China, and Taiwan'
:param strings: a list of words to join
:type string: :class:`collections.abc.Sequence`
:returns: a joined string
:rtype: :class:`str`, :class:`basestring`
"""
last = len(strings) - 1
if last == 0:
return strings[0]
elif last < 0:
return ''
iterator = enumerate(strings)
return ', '.join('and ' + s if i == last else s for i, s in iterator)
|
python
|
def and_join(strings):
"""Join the given ``strings`` by commas with last `' and '` conjuction.
>>> and_join(['Korea', 'Japan', 'China', 'Taiwan'])
'Korea, Japan, China, and Taiwan'
:param strings: a list of words to join
:type string: :class:`collections.abc.Sequence`
:returns: a joined string
:rtype: :class:`str`, :class:`basestring`
"""
last = len(strings) - 1
if last == 0:
return strings[0]
elif last < 0:
return ''
iterator = enumerate(strings)
return ', '.join('and ' + s if i == last else s for i, s in iterator)
|
[
"def",
"and_join",
"(",
"strings",
")",
":",
"last",
"=",
"len",
"(",
"strings",
")",
"-",
"1",
"if",
"last",
"==",
"0",
":",
"return",
"strings",
"[",
"0",
"]",
"elif",
"last",
"<",
"0",
":",
"return",
"''",
"iterator",
"=",
"enumerate",
"(",
"strings",
")",
"return",
"', '",
".",
"join",
"(",
"'and '",
"+",
"s",
"if",
"i",
"==",
"last",
"else",
"s",
"for",
"i",
",",
"s",
"in",
"iterator",
")"
] |
Join the given ``strings`` by commas with last `' and '` conjuction.
>>> and_join(['Korea', 'Japan', 'China', 'Taiwan'])
'Korea, Japan, China, and Taiwan'
:param strings: a list of words to join
:type string: :class:`collections.abc.Sequence`
:returns: a joined string
:rtype: :class:`str`, :class:`basestring`
|
[
"Join",
"the",
"given",
"strings",
"by",
"commas",
"with",
"last",
"and",
"conjuction",
"."
] |
fde5b18bc761f0253e71685ee5489e4beb8a403e
|
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sass.py#L741-L759
|
11,887
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
allow_staff_or_superuser
|
def allow_staff_or_superuser(func):
"""
This decorator is used to abstract common is_staff and is_superuser functionality
out of permission checks. It determines which parameter is the request based on name.
"""
is_object_permission = "has_object" in func.__name__
@wraps(func)
def func_wrapper(*args, **kwargs):
request = args[0]
# use second parameter if object permission
if is_object_permission:
request = args[1]
if request.user.is_staff or request.user.is_superuser:
return True
return func(*args, **kwargs)
return func_wrapper
|
python
|
def allow_staff_or_superuser(func):
"""
This decorator is used to abstract common is_staff and is_superuser functionality
out of permission checks. It determines which parameter is the request based on name.
"""
is_object_permission = "has_object" in func.__name__
@wraps(func)
def func_wrapper(*args, **kwargs):
request = args[0]
# use second parameter if object permission
if is_object_permission:
request = args[1]
if request.user.is_staff or request.user.is_superuser:
return True
return func(*args, **kwargs)
return func_wrapper
|
[
"def",
"allow_staff_or_superuser",
"(",
"func",
")",
":",
"is_object_permission",
"=",
"\"has_object\"",
"in",
"func",
".",
"__name__",
"@",
"wraps",
"(",
"func",
")",
"def",
"func_wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"request",
"=",
"args",
"[",
"0",
"]",
"# use second parameter if object permission",
"if",
"is_object_permission",
":",
"request",
"=",
"args",
"[",
"1",
"]",
"if",
"request",
".",
"user",
".",
"is_staff",
"or",
"request",
".",
"user",
".",
"is_superuser",
":",
"return",
"True",
"return",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"func_wrapper"
] |
This decorator is used to abstract common is_staff and is_superuser functionality
out of permission checks. It determines which parameter is the request based on name.
|
[
"This",
"decorator",
"is",
"used",
"to",
"abstract",
"common",
"is_staff",
"and",
"is_superuser",
"functionality",
"out",
"of",
"permission",
"checks",
".",
"It",
"determines",
"which",
"parameter",
"is",
"the",
"request",
"based",
"on",
"name",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L269-L288
|
11,888
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
authenticated_users
|
def authenticated_users(func):
"""
This decorator is used to abstract common authentication checking functionality
out of permission checks. It determines which parameter is the request based on name.
"""
is_object_permission = "has_object" in func.__name__
@wraps(func)
def func_wrapper(*args, **kwargs):
request = args[0]
# use second parameter if object permission
if is_object_permission:
request = args[1]
if not(request.user and request.user.is_authenticated):
return False
return func(*args, **kwargs)
return func_wrapper
|
python
|
def authenticated_users(func):
"""
This decorator is used to abstract common authentication checking functionality
out of permission checks. It determines which parameter is the request based on name.
"""
is_object_permission = "has_object" in func.__name__
@wraps(func)
def func_wrapper(*args, **kwargs):
request = args[0]
# use second parameter if object permission
if is_object_permission:
request = args[1]
if not(request.user and request.user.is_authenticated):
return False
return func(*args, **kwargs)
return func_wrapper
|
[
"def",
"authenticated_users",
"(",
"func",
")",
":",
"is_object_permission",
"=",
"\"has_object\"",
"in",
"func",
".",
"__name__",
"@",
"wraps",
"(",
"func",
")",
"def",
"func_wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"request",
"=",
"args",
"[",
"0",
"]",
"# use second parameter if object permission",
"if",
"is_object_permission",
":",
"request",
"=",
"args",
"[",
"1",
"]",
"if",
"not",
"(",
"request",
".",
"user",
"and",
"request",
".",
"user",
".",
"is_authenticated",
")",
":",
"return",
"False",
"return",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"func_wrapper"
] |
This decorator is used to abstract common authentication checking functionality
out of permission checks. It determines which parameter is the request based on name.
|
[
"This",
"decorator",
"is",
"used",
"to",
"abstract",
"common",
"authentication",
"checking",
"functionality",
"out",
"of",
"permission",
"checks",
".",
"It",
"determines",
"which",
"parameter",
"is",
"the",
"request",
"based",
"on",
"name",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L291-L310
|
11,889
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
DRYPermissionFiltersBase.filter_queryset
|
def filter_queryset(self, request, queryset, view):
"""
This method overrides the standard filter_queryset method.
This method will check to see if the view calling this is from
a list type action. This function will also route the filter
by action type if action_routing is set to True.
"""
# Check if this is a list type request
if view.lookup_field not in view.kwargs:
if not self.action_routing:
return self.filter_list_queryset(request, queryset, view)
else:
method_name = "filter_{action}_queryset".format(action=view.action)
return getattr(self, method_name)(request, queryset, view)
return queryset
|
python
|
def filter_queryset(self, request, queryset, view):
"""
This method overrides the standard filter_queryset method.
This method will check to see if the view calling this is from
a list type action. This function will also route the filter
by action type if action_routing is set to True.
"""
# Check if this is a list type request
if view.lookup_field not in view.kwargs:
if not self.action_routing:
return self.filter_list_queryset(request, queryset, view)
else:
method_name = "filter_{action}_queryset".format(action=view.action)
return getattr(self, method_name)(request, queryset, view)
return queryset
|
[
"def",
"filter_queryset",
"(",
"self",
",",
"request",
",",
"queryset",
",",
"view",
")",
":",
"# Check if this is a list type request",
"if",
"view",
".",
"lookup_field",
"not",
"in",
"view",
".",
"kwargs",
":",
"if",
"not",
"self",
".",
"action_routing",
":",
"return",
"self",
".",
"filter_list_queryset",
"(",
"request",
",",
"queryset",
",",
"view",
")",
"else",
":",
"method_name",
"=",
"\"filter_{action}_queryset\"",
".",
"format",
"(",
"action",
"=",
"view",
".",
"action",
")",
"return",
"getattr",
"(",
"self",
",",
"method_name",
")",
"(",
"request",
",",
"queryset",
",",
"view",
")",
"return",
"queryset"
] |
This method overrides the standard filter_queryset method.
This method will check to see if the view calling this is from
a list type action. This function will also route the filter
by action type if action_routing is set to True.
|
[
"This",
"method",
"overrides",
"the",
"standard",
"filter_queryset",
"method",
".",
"This",
"method",
"will",
"check",
"to",
"see",
"if",
"the",
"view",
"calling",
"this",
"is",
"from",
"a",
"list",
"type",
"action",
".",
"This",
"function",
"will",
"also",
"route",
"the",
"filter",
"by",
"action",
"type",
"if",
"action_routing",
"is",
"set",
"to",
"True",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L35-L49
|
11,890
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
DRYPermissions.has_permission
|
def has_permission(self, request, view):
"""
Overrides the standard function and figures out methods to call for global permissions.
"""
if not self.global_permissions:
return True
serializer_class = view.get_serializer_class()
assert serializer_class.Meta.model is not None, (
"global_permissions set to true without a model "
"set on the serializer for '%s'" % view.__class__.__name__
)
model_class = serializer_class.Meta.model
action_method_name = None
if hasattr(view, 'action'):
action = self._get_action(view.action)
action_method_name = "has_{action}_permission".format(action=action)
# If the specific action permission exists then use it, otherwise use general.
if hasattr(model_class, action_method_name):
return getattr(model_class, action_method_name)(request)
if request.method in permissions.SAFE_METHODS:
assert hasattr(model_class, 'has_read_permission'), \
self._get_error_message(model_class, 'has_read_permission', action_method_name)
return model_class.has_read_permission(request)
else:
assert hasattr(model_class, 'has_write_permission'), \
self._get_error_message(model_class, 'has_write_permission', action_method_name)
return model_class.has_write_permission(request)
|
python
|
def has_permission(self, request, view):
"""
Overrides the standard function and figures out methods to call for global permissions.
"""
if not self.global_permissions:
return True
serializer_class = view.get_serializer_class()
assert serializer_class.Meta.model is not None, (
"global_permissions set to true without a model "
"set on the serializer for '%s'" % view.__class__.__name__
)
model_class = serializer_class.Meta.model
action_method_name = None
if hasattr(view, 'action'):
action = self._get_action(view.action)
action_method_name = "has_{action}_permission".format(action=action)
# If the specific action permission exists then use it, otherwise use general.
if hasattr(model_class, action_method_name):
return getattr(model_class, action_method_name)(request)
if request.method in permissions.SAFE_METHODS:
assert hasattr(model_class, 'has_read_permission'), \
self._get_error_message(model_class, 'has_read_permission', action_method_name)
return model_class.has_read_permission(request)
else:
assert hasattr(model_class, 'has_write_permission'), \
self._get_error_message(model_class, 'has_write_permission', action_method_name)
return model_class.has_write_permission(request)
|
[
"def",
"has_permission",
"(",
"self",
",",
"request",
",",
"view",
")",
":",
"if",
"not",
"self",
".",
"global_permissions",
":",
"return",
"True",
"serializer_class",
"=",
"view",
".",
"get_serializer_class",
"(",
")",
"assert",
"serializer_class",
".",
"Meta",
".",
"model",
"is",
"not",
"None",
",",
"(",
"\"global_permissions set to true without a model \"",
"\"set on the serializer for '%s'\"",
"%",
"view",
".",
"__class__",
".",
"__name__",
")",
"model_class",
"=",
"serializer_class",
".",
"Meta",
".",
"model",
"action_method_name",
"=",
"None",
"if",
"hasattr",
"(",
"view",
",",
"'action'",
")",
":",
"action",
"=",
"self",
".",
"_get_action",
"(",
"view",
".",
"action",
")",
"action_method_name",
"=",
"\"has_{action}_permission\"",
".",
"format",
"(",
"action",
"=",
"action",
")",
"# If the specific action permission exists then use it, otherwise use general.",
"if",
"hasattr",
"(",
"model_class",
",",
"action_method_name",
")",
":",
"return",
"getattr",
"(",
"model_class",
",",
"action_method_name",
")",
"(",
"request",
")",
"if",
"request",
".",
"method",
"in",
"permissions",
".",
"SAFE_METHODS",
":",
"assert",
"hasattr",
"(",
"model_class",
",",
"'has_read_permission'",
")",
",",
"self",
".",
"_get_error_message",
"(",
"model_class",
",",
"'has_read_permission'",
",",
"action_method_name",
")",
"return",
"model_class",
".",
"has_read_permission",
"(",
"request",
")",
"else",
":",
"assert",
"hasattr",
"(",
"model_class",
",",
"'has_write_permission'",
")",
",",
"self",
".",
"_get_error_message",
"(",
"model_class",
",",
"'has_write_permission'",
",",
"action_method_name",
")",
"return",
"model_class",
".",
"has_write_permission",
"(",
"request",
")"
] |
Overrides the standard function and figures out methods to call for global permissions.
|
[
"Overrides",
"the",
"standard",
"function",
"and",
"figures",
"out",
"methods",
"to",
"call",
"for",
"global",
"permissions",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L97-L128
|
11,891
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
DRYPermissions.has_object_permission
|
def has_object_permission(self, request, view, obj):
"""
Overrides the standard function and figures out methods to call for object permissions.
"""
if not self.object_permissions:
return True
serializer_class = view.get_serializer_class()
model_class = serializer_class.Meta.model
action_method_name = None
if hasattr(view, 'action'):
action = self._get_action(view.action)
action_method_name = "has_object_{action}_permission".format(action=action)
# If the specific action permission exists then use it, otherwise use general.
if hasattr(obj, action_method_name):
return getattr(obj, action_method_name)(request)
if request.method in permissions.SAFE_METHODS:
assert hasattr(obj, 'has_object_read_permission'), \
self._get_error_message(model_class, 'has_object_read_permission', action_method_name)
return obj.has_object_read_permission(request)
else:
assert hasattr(obj, 'has_object_write_permission'), \
self._get_error_message(model_class, 'has_object_write_permission', action_method_name)
return obj.has_object_write_permission(request)
|
python
|
def has_object_permission(self, request, view, obj):
"""
Overrides the standard function and figures out methods to call for object permissions.
"""
if not self.object_permissions:
return True
serializer_class = view.get_serializer_class()
model_class = serializer_class.Meta.model
action_method_name = None
if hasattr(view, 'action'):
action = self._get_action(view.action)
action_method_name = "has_object_{action}_permission".format(action=action)
# If the specific action permission exists then use it, otherwise use general.
if hasattr(obj, action_method_name):
return getattr(obj, action_method_name)(request)
if request.method in permissions.SAFE_METHODS:
assert hasattr(obj, 'has_object_read_permission'), \
self._get_error_message(model_class, 'has_object_read_permission', action_method_name)
return obj.has_object_read_permission(request)
else:
assert hasattr(obj, 'has_object_write_permission'), \
self._get_error_message(model_class, 'has_object_write_permission', action_method_name)
return obj.has_object_write_permission(request)
|
[
"def",
"has_object_permission",
"(",
"self",
",",
"request",
",",
"view",
",",
"obj",
")",
":",
"if",
"not",
"self",
".",
"object_permissions",
":",
"return",
"True",
"serializer_class",
"=",
"view",
".",
"get_serializer_class",
"(",
")",
"model_class",
"=",
"serializer_class",
".",
"Meta",
".",
"model",
"action_method_name",
"=",
"None",
"if",
"hasattr",
"(",
"view",
",",
"'action'",
")",
":",
"action",
"=",
"self",
".",
"_get_action",
"(",
"view",
".",
"action",
")",
"action_method_name",
"=",
"\"has_object_{action}_permission\"",
".",
"format",
"(",
"action",
"=",
"action",
")",
"# If the specific action permission exists then use it, otherwise use general.",
"if",
"hasattr",
"(",
"obj",
",",
"action_method_name",
")",
":",
"return",
"getattr",
"(",
"obj",
",",
"action_method_name",
")",
"(",
"request",
")",
"if",
"request",
".",
"method",
"in",
"permissions",
".",
"SAFE_METHODS",
":",
"assert",
"hasattr",
"(",
"obj",
",",
"'has_object_read_permission'",
")",
",",
"self",
".",
"_get_error_message",
"(",
"model_class",
",",
"'has_object_read_permission'",
",",
"action_method_name",
")",
"return",
"obj",
".",
"has_object_read_permission",
"(",
"request",
")",
"else",
":",
"assert",
"hasattr",
"(",
"obj",
",",
"'has_object_write_permission'",
")",
",",
"self",
".",
"_get_error_message",
"(",
"model_class",
",",
"'has_object_write_permission'",
",",
"action_method_name",
")",
"return",
"obj",
".",
"has_object_write_permission",
"(",
"request",
")"
] |
Overrides the standard function and figures out methods to call for object permissions.
|
[
"Overrides",
"the",
"standard",
"function",
"and",
"figures",
"out",
"methods",
"to",
"call",
"for",
"object",
"permissions",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L130-L154
|
11,892
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
DRYPermissions._get_action
|
def _get_action(self, action):
"""
Utility function that consolidates actions if necessary.
"""
return_action = action
if self.partial_update_is_update and action == 'partial_update':
return_action = 'update'
return return_action
|
python
|
def _get_action(self, action):
"""
Utility function that consolidates actions if necessary.
"""
return_action = action
if self.partial_update_is_update and action == 'partial_update':
return_action = 'update'
return return_action
|
[
"def",
"_get_action",
"(",
"self",
",",
"action",
")",
":",
"return_action",
"=",
"action",
"if",
"self",
".",
"partial_update_is_update",
"and",
"action",
"==",
"'partial_update'",
":",
"return_action",
"=",
"'update'",
"return",
"return_action"
] |
Utility function that consolidates actions if necessary.
|
[
"Utility",
"function",
"that",
"consolidates",
"actions",
"if",
"necessary",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L156-L163
|
11,893
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
DRYPermissions._get_error_message
|
def _get_error_message(self, model_class, method_name, action_method_name):
"""
Get assertion error message depending if there are actions permissions methods defined.
"""
if action_method_name:
return "'{}' does not have '{}' or '{}' defined.".format(model_class, method_name, action_method_name)
else:
return "'{}' does not have '{}' defined.".format(model_class, method_name)
|
python
|
def _get_error_message(self, model_class, method_name, action_method_name):
"""
Get assertion error message depending if there are actions permissions methods defined.
"""
if action_method_name:
return "'{}' does not have '{}' or '{}' defined.".format(model_class, method_name, action_method_name)
else:
return "'{}' does not have '{}' defined.".format(model_class, method_name)
|
[
"def",
"_get_error_message",
"(",
"self",
",",
"model_class",
",",
"method_name",
",",
"action_method_name",
")",
":",
"if",
"action_method_name",
":",
"return",
"\"'{}' does not have '{}' or '{}' defined.\"",
".",
"format",
"(",
"model_class",
",",
"method_name",
",",
"action_method_name",
")",
"else",
":",
"return",
"\"'{}' does not have '{}' defined.\"",
".",
"format",
"(",
"model_class",
",",
"method_name",
")"
] |
Get assertion error message depending if there are actions permissions methods defined.
|
[
"Get",
"assertion",
"error",
"message",
"depending",
"if",
"there",
"are",
"actions",
"permissions",
"methods",
"defined",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L165-L172
|
11,894
|
dbkaplan/dry-rest-permissions
|
dry_rest_permissions/generics.py
|
DRYPermissionsField.bind
|
def bind(self, field_name, parent):
"""
Check the model attached to the serializer to see what methods are defined and save them.
"""
assert parent.Meta.model is not None, \
"DRYPermissions is used on '{}' without a model".format(parent.__class__.__name__)
for action in self.actions:
if not self.object_only:
global_method_name = "has_{action}_permission".format(action=action)
if hasattr(parent.Meta.model, global_method_name):
self.action_method_map[action] = {'global': global_method_name}
if not self.global_only:
object_method_name = "has_object_{action}_permission".format(action=action)
if hasattr(parent.Meta.model, object_method_name):
if self.action_method_map.get(action, None) is None:
self.action_method_map[action] = {}
self.action_method_map[action]['object'] = object_method_name
super(DRYPermissionsField, self).bind(field_name, parent)
|
python
|
def bind(self, field_name, parent):
"""
Check the model attached to the serializer to see what methods are defined and save them.
"""
assert parent.Meta.model is not None, \
"DRYPermissions is used on '{}' without a model".format(parent.__class__.__name__)
for action in self.actions:
if not self.object_only:
global_method_name = "has_{action}_permission".format(action=action)
if hasattr(parent.Meta.model, global_method_name):
self.action_method_map[action] = {'global': global_method_name}
if not self.global_only:
object_method_name = "has_object_{action}_permission".format(action=action)
if hasattr(parent.Meta.model, object_method_name):
if self.action_method_map.get(action, None) is None:
self.action_method_map[action] = {}
self.action_method_map[action]['object'] = object_method_name
super(DRYPermissionsField, self).bind(field_name, parent)
|
[
"def",
"bind",
"(",
"self",
",",
"field_name",
",",
"parent",
")",
":",
"assert",
"parent",
".",
"Meta",
".",
"model",
"is",
"not",
"None",
",",
"\"DRYPermissions is used on '{}' without a model\"",
".",
"format",
"(",
"parent",
".",
"__class__",
".",
"__name__",
")",
"for",
"action",
"in",
"self",
".",
"actions",
":",
"if",
"not",
"self",
".",
"object_only",
":",
"global_method_name",
"=",
"\"has_{action}_permission\"",
".",
"format",
"(",
"action",
"=",
"action",
")",
"if",
"hasattr",
"(",
"parent",
".",
"Meta",
".",
"model",
",",
"global_method_name",
")",
":",
"self",
".",
"action_method_map",
"[",
"action",
"]",
"=",
"{",
"'global'",
":",
"global_method_name",
"}",
"if",
"not",
"self",
".",
"global_only",
":",
"object_method_name",
"=",
"\"has_object_{action}_permission\"",
".",
"format",
"(",
"action",
"=",
"action",
")",
"if",
"hasattr",
"(",
"parent",
".",
"Meta",
".",
"model",
",",
"object_method_name",
")",
":",
"if",
"self",
".",
"action_method_map",
".",
"get",
"(",
"action",
",",
"None",
")",
"is",
"None",
":",
"self",
".",
"action_method_map",
"[",
"action",
"]",
"=",
"{",
"}",
"self",
".",
"action_method_map",
"[",
"action",
"]",
"[",
"'object'",
"]",
"=",
"object_method_name",
"super",
"(",
"DRYPermissionsField",
",",
"self",
")",
".",
"bind",
"(",
"field_name",
",",
"parent",
")"
] |
Check the model attached to the serializer to see what methods are defined and save them.
|
[
"Check",
"the",
"model",
"attached",
"to",
"the",
"serializer",
"to",
"see",
"what",
"methods",
"are",
"defined",
"and",
"save",
"them",
"."
] |
b2d4d3c76041f6c405e2537bea9639657b75b90e
|
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L229-L250
|
11,895
|
toastdriven/restless
|
restless/resources.py
|
skip_prepare
|
def skip_prepare(func):
"""
A convenience decorator for indicating the raw data should not be prepared.
"""
@wraps(func)
def _wrapper(self, *args, **kwargs):
value = func(self, *args, **kwargs)
return Data(value, should_prepare=False)
return _wrapper
|
python
|
def skip_prepare(func):
"""
A convenience decorator for indicating the raw data should not be prepared.
"""
@wraps(func)
def _wrapper(self, *args, **kwargs):
value = func(self, *args, **kwargs)
return Data(value, should_prepare=False)
return _wrapper
|
[
"def",
"skip_prepare",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"_wrapper",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"value",
"=",
"func",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"Data",
"(",
"value",
",",
"should_prepare",
"=",
"False",
")",
"return",
"_wrapper"
] |
A convenience decorator for indicating the raw data should not be prepared.
|
[
"A",
"convenience",
"decorator",
"for",
"indicating",
"the",
"raw",
"data",
"should",
"not",
"be",
"prepared",
"."
] |
661593b7b43c42d1bc508dec795356297991255e
|
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L12-L20
|
11,896
|
toastdriven/restless
|
restless/resources.py
|
Resource.build_error
|
def build_error(self, err):
"""
When an exception is encountered, this generates a JSON error message
for display to the user.
:param err: The exception seen. The message is exposed to the user, so
beware of sensitive data leaking.
:type err: Exception
:returns: A response object
"""
data = {
'error': err.args[0],
}
if self.is_debug():
# Add the traceback.
data['traceback'] = format_traceback(sys.exc_info())
body = self.serializer.serialize(data)
status = getattr(err, 'status', 500)
return self.build_response(body, status=status)
|
python
|
def build_error(self, err):
"""
When an exception is encountered, this generates a JSON error message
for display to the user.
:param err: The exception seen. The message is exposed to the user, so
beware of sensitive data leaking.
:type err: Exception
:returns: A response object
"""
data = {
'error': err.args[0],
}
if self.is_debug():
# Add the traceback.
data['traceback'] = format_traceback(sys.exc_info())
body = self.serializer.serialize(data)
status = getattr(err, 'status', 500)
return self.build_response(body, status=status)
|
[
"def",
"build_error",
"(",
"self",
",",
"err",
")",
":",
"data",
"=",
"{",
"'error'",
":",
"err",
".",
"args",
"[",
"0",
"]",
",",
"}",
"if",
"self",
".",
"is_debug",
"(",
")",
":",
"# Add the traceback.",
"data",
"[",
"'traceback'",
"]",
"=",
"format_traceback",
"(",
"sys",
".",
"exc_info",
"(",
")",
")",
"body",
"=",
"self",
".",
"serializer",
".",
"serialize",
"(",
"data",
")",
"status",
"=",
"getattr",
"(",
"err",
",",
"'status'",
",",
"500",
")",
"return",
"self",
".",
"build_response",
"(",
"body",
",",
"status",
"=",
"status",
")"
] |
When an exception is encountered, this generates a JSON error message
for display to the user.
:param err: The exception seen. The message is exposed to the user, so
beware of sensitive data leaking.
:type err: Exception
:returns: A response object
|
[
"When",
"an",
"exception",
"is",
"encountered",
"this",
"generates",
"a",
"JSON",
"error",
"message",
"for",
"display",
"to",
"the",
"user",
"."
] |
661593b7b43c42d1bc508dec795356297991255e
|
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L192-L213
|
11,897
|
toastdriven/restless
|
restless/resources.py
|
Resource.deserialize
|
def deserialize(self, method, endpoint, body):
"""
A convenience method for deserializing the body of a request.
If called on a list-style endpoint, this calls ``deserialize_list``.
Otherwise, it will call ``deserialize_detail``.
:param method: The HTTP method of the current request
:type method: string
:param endpoint: The endpoint style (``list`` or ``detail``)
:type endpoint: string
:param body: The body of the current request
:type body: string
:returns: The deserialized data
:rtype: ``list`` or ``dict``
"""
if endpoint == 'list':
return self.deserialize_list(body)
return self.deserialize_detail(body)
|
python
|
def deserialize(self, method, endpoint, body):
"""
A convenience method for deserializing the body of a request.
If called on a list-style endpoint, this calls ``deserialize_list``.
Otherwise, it will call ``deserialize_detail``.
:param method: The HTTP method of the current request
:type method: string
:param endpoint: The endpoint style (``list`` or ``detail``)
:type endpoint: string
:param body: The body of the current request
:type body: string
:returns: The deserialized data
:rtype: ``list`` or ``dict``
"""
if endpoint == 'list':
return self.deserialize_list(body)
return self.deserialize_detail(body)
|
[
"def",
"deserialize",
"(",
"self",
",",
"method",
",",
"endpoint",
",",
"body",
")",
":",
"if",
"endpoint",
"==",
"'list'",
":",
"return",
"self",
".",
"deserialize_list",
"(",
"body",
")",
"return",
"self",
".",
"deserialize_detail",
"(",
"body",
")"
] |
A convenience method for deserializing the body of a request.
If called on a list-style endpoint, this calls ``deserialize_list``.
Otherwise, it will call ``deserialize_detail``.
:param method: The HTTP method of the current request
:type method: string
:param endpoint: The endpoint style (``list`` or ``detail``)
:type endpoint: string
:param body: The body of the current request
:type body: string
:returns: The deserialized data
:rtype: ``list`` or ``dict``
|
[
"A",
"convenience",
"method",
"for",
"deserializing",
"the",
"body",
"of",
"a",
"request",
"."
] |
661593b7b43c42d1bc508dec795356297991255e
|
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L310-L332
|
11,898
|
toastdriven/restless
|
restless/resources.py
|
Resource.serialize
|
def serialize(self, method, endpoint, data):
"""
A convenience method for serializing data for a response.
If called on a list-style endpoint, this calls ``serialize_list``.
Otherwise, it will call ``serialize_detail``.
:param method: The HTTP method of the current request
:type method: string
:param endpoint: The endpoint style (``list`` or ``detail``)
:type endpoint: string
:param data: The body for the response
:type data: string
:returns: A serialized version of the data
:rtype: string
"""
if endpoint == 'list':
# Create is a special-case, because you POST it to the collection,
# not to a detail.
if method == 'POST':
return self.serialize_detail(data)
return self.serialize_list(data)
return self.serialize_detail(data)
|
python
|
def serialize(self, method, endpoint, data):
"""
A convenience method for serializing data for a response.
If called on a list-style endpoint, this calls ``serialize_list``.
Otherwise, it will call ``serialize_detail``.
:param method: The HTTP method of the current request
:type method: string
:param endpoint: The endpoint style (``list`` or ``detail``)
:type endpoint: string
:param data: The body for the response
:type data: string
:returns: A serialized version of the data
:rtype: string
"""
if endpoint == 'list':
# Create is a special-case, because you POST it to the collection,
# not to a detail.
if method == 'POST':
return self.serialize_detail(data)
return self.serialize_list(data)
return self.serialize_detail(data)
|
[
"def",
"serialize",
"(",
"self",
",",
"method",
",",
"endpoint",
",",
"data",
")",
":",
"if",
"endpoint",
"==",
"'list'",
":",
"# Create is a special-case, because you POST it to the collection,",
"# not to a detail.",
"if",
"method",
"==",
"'POST'",
":",
"return",
"self",
".",
"serialize_detail",
"(",
"data",
")",
"return",
"self",
".",
"serialize_list",
"(",
"data",
")",
"return",
"self",
".",
"serialize_detail",
"(",
"data",
")"
] |
A convenience method for serializing data for a response.
If called on a list-style endpoint, this calls ``serialize_list``.
Otherwise, it will call ``serialize_detail``.
:param method: The HTTP method of the current request
:type method: string
:param endpoint: The endpoint style (``list`` or ``detail``)
:type endpoint: string
:param data: The body for the response
:type data: string
:returns: A serialized version of the data
:rtype: string
|
[
"A",
"convenience",
"method",
"for",
"serializing",
"data",
"for",
"a",
"response",
"."
] |
661593b7b43c42d1bc508dec795356297991255e
|
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L362-L388
|
11,899
|
toastdriven/restless
|
restless/tnd.py
|
_method
|
def _method(self, *args, **kwargs):
"""
the body of those http-methods used in tornado.web.RequestHandler
"""
yield self.resource_handler.handle(self.__resource_view_type__, *args, **kwargs)
|
python
|
def _method(self, *args, **kwargs):
"""
the body of those http-methods used in tornado.web.RequestHandler
"""
yield self.resource_handler.handle(self.__resource_view_type__, *args, **kwargs)
|
[
"def",
"_method",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"yield",
"self",
".",
"resource_handler",
".",
"handle",
"(",
"self",
".",
"__resource_view_type__",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
the body of those http-methods used in tornado.web.RequestHandler
|
[
"the",
"body",
"of",
"those",
"http",
"-",
"methods",
"used",
"in",
"tornado",
".",
"web",
".",
"RequestHandler"
] |
661593b7b43c42d1bc508dec795356297991255e
|
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/tnd.py#L36-L40
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.