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,200
|
Gandi/gandi.cli
|
gandi/cli/commands/config.py
|
get
|
def get(gandi, g, key):
"""Display value of a given config key."""
val = gandi.get(key=key, global_=g)
if not val:
gandi.echo("No value found.")
sys.exit(1)
gandi.echo(val)
|
python
|
def get(gandi, g, key):
"""Display value of a given config key."""
val = gandi.get(key=key, global_=g)
if not val:
gandi.echo("No value found.")
sys.exit(1)
gandi.echo(val)
|
[
"def",
"get",
"(",
"gandi",
",",
"g",
",",
"key",
")",
":",
"val",
"=",
"gandi",
".",
"get",
"(",
"key",
"=",
"key",
",",
"global_",
"=",
"g",
")",
"if",
"not",
"val",
":",
"gandi",
".",
"echo",
"(",
"\"No value found.\"",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"gandi",
".",
"echo",
"(",
"val",
")"
] |
Display value of a given config key.
|
[
"Display",
"value",
"of",
"a",
"given",
"config",
"key",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/config.py#L26-L32
|
11,201
|
Gandi/gandi.cli
|
gandi/cli/commands/config.py
|
edit
|
def edit(gandi, g):
"""Edit config file with prefered text editor"""
config_file = gandi.home_config if g else gandi.local_config
path = os.path.expanduser(config_file)
editor = gandi.get('editor')
if not editor:
try:
editor = click.prompt("Please enter the path of your prefered "
"editor. eg: '/usr/bin/vi' or 'vi'")
except Abort:
gandi.echo("""
Warning: editor is not configured.
You can use both 'gandi config set [-g] editor <value>'
or the $EDITOR environment variable to configure it.""")
sys.exit(1)
subprocess.call([editor, path])
|
python
|
def edit(gandi, g):
"""Edit config file with prefered text editor"""
config_file = gandi.home_config if g else gandi.local_config
path = os.path.expanduser(config_file)
editor = gandi.get('editor')
if not editor:
try:
editor = click.prompt("Please enter the path of your prefered "
"editor. eg: '/usr/bin/vi' or 'vi'")
except Abort:
gandi.echo("""
Warning: editor is not configured.
You can use both 'gandi config set [-g] editor <value>'
or the $EDITOR environment variable to configure it.""")
sys.exit(1)
subprocess.call([editor, path])
|
[
"def",
"edit",
"(",
"gandi",
",",
"g",
")",
":",
"config_file",
"=",
"gandi",
".",
"home_config",
"if",
"g",
"else",
"gandi",
".",
"local_config",
"path",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"config_file",
")",
"editor",
"=",
"gandi",
".",
"get",
"(",
"'editor'",
")",
"if",
"not",
"editor",
":",
"try",
":",
"editor",
"=",
"click",
".",
"prompt",
"(",
"\"Please enter the path of your prefered \"",
"\"editor. eg: '/usr/bin/vi' or 'vi'\"",
")",
"except",
"Abort",
":",
"gandi",
".",
"echo",
"(",
"\"\"\"\nWarning: editor is not configured.\nYou can use both 'gandi config set [-g] editor <value>'\nor the $EDITOR environment variable to configure it.\"\"\"",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"subprocess",
".",
"call",
"(",
"[",
"editor",
",",
"path",
"]",
")"
] |
Edit config file with prefered text editor
|
[
"Edit",
"config",
"file",
"with",
"prefered",
"text",
"editor"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/config.py#L50-L66
|
11,202
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.delete
|
def delete(cls, name):
""" Delete a webaccelerator """
result = cls.call('hosting.rproxy.delete', cls.usable_id(name))
cls.echo('Deleting your webaccelerator named %s' % name)
cls.display_progress(result)
cls.echo('Webaccelerator have been deleted')
return result
|
python
|
def delete(cls, name):
""" Delete a webaccelerator """
result = cls.call('hosting.rproxy.delete', cls.usable_id(name))
cls.echo('Deleting your webaccelerator named %s' % name)
cls.display_progress(result)
cls.echo('Webaccelerator have been deleted')
return result
|
[
"def",
"delete",
"(",
"cls",
",",
"name",
")",
":",
"result",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.delete'",
",",
"cls",
".",
"usable_id",
"(",
"name",
")",
")",
"cls",
".",
"echo",
"(",
"'Deleting your webaccelerator named %s'",
"%",
"name",
")",
"cls",
".",
"display_progress",
"(",
"result",
")",
"cls",
".",
"echo",
"(",
"'Webaccelerator have been deleted'",
")",
"return",
"result"
] |
Delete a webaccelerator
|
[
"Delete",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L104-L110
|
11,203
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.backend_add
|
def backend_add(cls, name, backend):
""" Add a backend into a webaccelerator """
oper = cls.call(
'hosting.rproxy.server.create', cls.usable_id(name), backend)
cls.echo('Adding backend %s:%s into webaccelerator' %
(backend['ip'], backend['port']))
cls.display_progress(oper)
cls.echo('Backend added')
return oper
|
python
|
def backend_add(cls, name, backend):
""" Add a backend into a webaccelerator """
oper = cls.call(
'hosting.rproxy.server.create', cls.usable_id(name), backend)
cls.echo('Adding backend %s:%s into webaccelerator' %
(backend['ip'], backend['port']))
cls.display_progress(oper)
cls.echo('Backend added')
return oper
|
[
"def",
"backend_add",
"(",
"cls",
",",
"name",
",",
"backend",
")",
":",
"oper",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.server.create'",
",",
"cls",
".",
"usable_id",
"(",
"name",
")",
",",
"backend",
")",
"cls",
".",
"echo",
"(",
"'Adding backend %s:%s into webaccelerator'",
"%",
"(",
"backend",
"[",
"'ip'",
"]",
",",
"backend",
"[",
"'port'",
"]",
")",
")",
"cls",
".",
"display_progress",
"(",
"oper",
")",
"cls",
".",
"echo",
"(",
"'Backend added'",
")",
"return",
"oper"
] |
Add a backend into a webaccelerator
|
[
"Add",
"a",
"backend",
"into",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L118-L126
|
11,204
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.backend_disable
|
def backend_disable(cls, backend):
""" Disable a backend for a server """
server = cls.backend_list(backend)
oper = cls.call('hosting.rproxy.server.disable',
server[0]['id'])
cls.echo('Desactivating backend on server %s' %
server[0]['ip'])
cls.display_progress(oper)
cls.echo('Backend desactivated')
return oper
|
python
|
def backend_disable(cls, backend):
""" Disable a backend for a server """
server = cls.backend_list(backend)
oper = cls.call('hosting.rproxy.server.disable',
server[0]['id'])
cls.echo('Desactivating backend on server %s' %
server[0]['ip'])
cls.display_progress(oper)
cls.echo('Backend desactivated')
return oper
|
[
"def",
"backend_disable",
"(",
"cls",
",",
"backend",
")",
":",
"server",
"=",
"cls",
".",
"backend_list",
"(",
"backend",
")",
"oper",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.server.disable'",
",",
"server",
"[",
"0",
"]",
"[",
"'id'",
"]",
")",
"cls",
".",
"echo",
"(",
"'Desactivating backend on server %s'",
"%",
"server",
"[",
"0",
"]",
"[",
"'ip'",
"]",
")",
"cls",
".",
"display_progress",
"(",
"oper",
")",
"cls",
".",
"echo",
"(",
"'Backend desactivated'",
")",
"return",
"oper"
] |
Disable a backend for a server
|
[
"Disable",
"a",
"backend",
"for",
"a",
"server"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L156-L165
|
11,205
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.vhost_add
|
def vhost_add(cls, resource, params):
""" Add a vhost into a webaccelerator """
try:
oper = cls.call(
'hosting.rproxy.vhost.create', cls.usable_id(resource), params)
cls.echo('Adding your virtual host (%s) into %s' %
(params['vhost'], resource))
cls.display_progress(oper)
cls.echo('Your virtual host habe been added')
return oper
except Exception as err:
if err.code == 580142:
dc = cls.info(resource)
dns_entry = cls.call('hosting.rproxy.vhost.get_dns_entries',
{'datacenter': dc['datacenter']['id'],
'vhost': params['vhost']})
txt_record = "%s 3600 IN TXT \"%s=%s\"" % (dns_entry['key'],
dns_entry['key'],
dns_entry['txt'])
cname_record = "%s 3600 IN CNAME %s" % (dns_entry['key'],
dns_entry['cname'])
cls.echo('The domain don\'t use Gandi DNS or you have not'
' sufficient right to alter the zone file. '
'Edit your zone file adding this TXT and CNAME '
'record and try again :')
cls.echo(txt_record)
cls.echo(cname_record)
cls.echo('\nOr add a file containing %s at :\n'
'http://%s/%s.txt\n' % (dns_entry['txt'],
dns_entry['domain'],
dns_entry['txt']))
else:
cls.echo(err)
|
python
|
def vhost_add(cls, resource, params):
""" Add a vhost into a webaccelerator """
try:
oper = cls.call(
'hosting.rproxy.vhost.create', cls.usable_id(resource), params)
cls.echo('Adding your virtual host (%s) into %s' %
(params['vhost'], resource))
cls.display_progress(oper)
cls.echo('Your virtual host habe been added')
return oper
except Exception as err:
if err.code == 580142:
dc = cls.info(resource)
dns_entry = cls.call('hosting.rproxy.vhost.get_dns_entries',
{'datacenter': dc['datacenter']['id'],
'vhost': params['vhost']})
txt_record = "%s 3600 IN TXT \"%s=%s\"" % (dns_entry['key'],
dns_entry['key'],
dns_entry['txt'])
cname_record = "%s 3600 IN CNAME %s" % (dns_entry['key'],
dns_entry['cname'])
cls.echo('The domain don\'t use Gandi DNS or you have not'
' sufficient right to alter the zone file. '
'Edit your zone file adding this TXT and CNAME '
'record and try again :')
cls.echo(txt_record)
cls.echo(cname_record)
cls.echo('\nOr add a file containing %s at :\n'
'http://%s/%s.txt\n' % (dns_entry['txt'],
dns_entry['domain'],
dns_entry['txt']))
else:
cls.echo(err)
|
[
"def",
"vhost_add",
"(",
"cls",
",",
"resource",
",",
"params",
")",
":",
"try",
":",
"oper",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.vhost.create'",
",",
"cls",
".",
"usable_id",
"(",
"resource",
")",
",",
"params",
")",
"cls",
".",
"echo",
"(",
"'Adding your virtual host (%s) into %s'",
"%",
"(",
"params",
"[",
"'vhost'",
"]",
",",
"resource",
")",
")",
"cls",
".",
"display_progress",
"(",
"oper",
")",
"cls",
".",
"echo",
"(",
"'Your virtual host habe been added'",
")",
"return",
"oper",
"except",
"Exception",
"as",
"err",
":",
"if",
"err",
".",
"code",
"==",
"580142",
":",
"dc",
"=",
"cls",
".",
"info",
"(",
"resource",
")",
"dns_entry",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.vhost.get_dns_entries'",
",",
"{",
"'datacenter'",
":",
"dc",
"[",
"'datacenter'",
"]",
"[",
"'id'",
"]",
",",
"'vhost'",
":",
"params",
"[",
"'vhost'",
"]",
"}",
")",
"txt_record",
"=",
"\"%s 3600 IN TXT \\\"%s=%s\\\"\"",
"%",
"(",
"dns_entry",
"[",
"'key'",
"]",
",",
"dns_entry",
"[",
"'key'",
"]",
",",
"dns_entry",
"[",
"'txt'",
"]",
")",
"cname_record",
"=",
"\"%s 3600 IN CNAME %s\"",
"%",
"(",
"dns_entry",
"[",
"'key'",
"]",
",",
"dns_entry",
"[",
"'cname'",
"]",
")",
"cls",
".",
"echo",
"(",
"'The domain don\\'t use Gandi DNS or you have not'",
"' sufficient right to alter the zone file. '",
"'Edit your zone file adding this TXT and CNAME '",
"'record and try again :'",
")",
"cls",
".",
"echo",
"(",
"txt_record",
")",
"cls",
".",
"echo",
"(",
"cname_record",
")",
"cls",
".",
"echo",
"(",
"'\\nOr add a file containing %s at :\\n'",
"'http://%s/%s.txt\\n'",
"%",
"(",
"dns_entry",
"[",
"'txt'",
"]",
",",
"dns_entry",
"[",
"'domain'",
"]",
",",
"dns_entry",
"[",
"'txt'",
"]",
")",
")",
"else",
":",
"cls",
".",
"echo",
"(",
"err",
")"
] |
Add a vhost into a webaccelerator
|
[
"Add",
"a",
"vhost",
"into",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L173-L208
|
11,206
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.vhost_remove
|
def vhost_remove(cls, name):
""" Delete a vhost in a webaccelerator """
oper = cls.call('hosting.rproxy.vhost.delete', name)
cls.echo('Deleting your virtual host %s' % name)
cls.display_progress(oper)
cls.echo('Your virtual host have been removed')
return oper
|
python
|
def vhost_remove(cls, name):
""" Delete a vhost in a webaccelerator """
oper = cls.call('hosting.rproxy.vhost.delete', name)
cls.echo('Deleting your virtual host %s' % name)
cls.display_progress(oper)
cls.echo('Your virtual host have been removed')
return oper
|
[
"def",
"vhost_remove",
"(",
"cls",
",",
"name",
")",
":",
"oper",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.vhost.delete'",
",",
"name",
")",
"cls",
".",
"echo",
"(",
"'Deleting your virtual host %s'",
"%",
"name",
")",
"cls",
".",
"display_progress",
"(",
"oper",
")",
"cls",
".",
"echo",
"(",
"'Your virtual host have been removed'",
")",
"return",
"oper"
] |
Delete a vhost in a webaccelerator
|
[
"Delete",
"a",
"vhost",
"in",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L211-L217
|
11,207
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.probe
|
def probe(cls, resource, enable, disable, test, host, interval,
http_method, http_response, threshold, timeout, url, window):
""" Set a probe for a webaccelerator """
params = {
'host': host,
'interval': interval,
'method': http_method,
'response': http_response,
'threshold': threshold,
'timeout': timeout,
'url': url,
'window': window
}
if enable:
params['enable'] = True
elif disable:
params['enable'] = False
if test:
result = cls.call(
'hosting.rproxy.probe.test', cls.usable_id(resource), params)
else:
result = cls.call(
'hosting.rproxy.probe.update', cls.usable_id(resource), params)
cls.display_progress(result)
return result
|
python
|
def probe(cls, resource, enable, disable, test, host, interval,
http_method, http_response, threshold, timeout, url, window):
""" Set a probe for a webaccelerator """
params = {
'host': host,
'interval': interval,
'method': http_method,
'response': http_response,
'threshold': threshold,
'timeout': timeout,
'url': url,
'window': window
}
if enable:
params['enable'] = True
elif disable:
params['enable'] = False
if test:
result = cls.call(
'hosting.rproxy.probe.test', cls.usable_id(resource), params)
else:
result = cls.call(
'hosting.rproxy.probe.update', cls.usable_id(resource), params)
cls.display_progress(result)
return result
|
[
"def",
"probe",
"(",
"cls",
",",
"resource",
",",
"enable",
",",
"disable",
",",
"test",
",",
"host",
",",
"interval",
",",
"http_method",
",",
"http_response",
",",
"threshold",
",",
"timeout",
",",
"url",
",",
"window",
")",
":",
"params",
"=",
"{",
"'host'",
":",
"host",
",",
"'interval'",
":",
"interval",
",",
"'method'",
":",
"http_method",
",",
"'response'",
":",
"http_response",
",",
"'threshold'",
":",
"threshold",
",",
"'timeout'",
":",
"timeout",
",",
"'url'",
":",
"url",
",",
"'window'",
":",
"window",
"}",
"if",
"enable",
":",
"params",
"[",
"'enable'",
"]",
"=",
"True",
"elif",
"disable",
":",
"params",
"[",
"'enable'",
"]",
"=",
"False",
"if",
"test",
":",
"result",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.probe.test'",
",",
"cls",
".",
"usable_id",
"(",
"resource",
")",
",",
"params",
")",
"else",
":",
"result",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.probe.update'",
",",
"cls",
".",
"usable_id",
"(",
"resource",
")",
",",
"params",
")",
"cls",
".",
"display_progress",
"(",
"result",
")",
"return",
"result"
] |
Set a probe for a webaccelerator
|
[
"Set",
"a",
"probe",
"for",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L220-L244
|
11,208
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.probe_enable
|
def probe_enable(cls, resource):
""" Activate a probe on a webaccelerator """
oper = cls.call('hosting.rproxy.probe.enable', cls.usable_id(resource))
cls.echo('Activating probe on %s' % resource)
cls.display_progress(oper)
cls.echo('The probe have been activated')
return oper
|
python
|
def probe_enable(cls, resource):
""" Activate a probe on a webaccelerator """
oper = cls.call('hosting.rproxy.probe.enable', cls.usable_id(resource))
cls.echo('Activating probe on %s' % resource)
cls.display_progress(oper)
cls.echo('The probe have been activated')
return oper
|
[
"def",
"probe_enable",
"(",
"cls",
",",
"resource",
")",
":",
"oper",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.probe.enable'",
",",
"cls",
".",
"usable_id",
"(",
"resource",
")",
")",
"cls",
".",
"echo",
"(",
"'Activating probe on %s'",
"%",
"resource",
")",
"cls",
".",
"display_progress",
"(",
"oper",
")",
"cls",
".",
"echo",
"(",
"'The probe have been activated'",
")",
"return",
"oper"
] |
Activate a probe on a webaccelerator
|
[
"Activate",
"a",
"probe",
"on",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L247-L253
|
11,209
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.probe_disable
|
def probe_disable(cls, resource):
""" Disable a probe on a webaccelerator """
oper = cls.call('hosting.rproxy.probe.disable',
cls.usable_id(resource))
cls.echo('Desactivating probe on %s' % resource)
cls.display_progress(oper)
cls.echo('The probe have been desactivated')
return oper
|
python
|
def probe_disable(cls, resource):
""" Disable a probe on a webaccelerator """
oper = cls.call('hosting.rproxy.probe.disable',
cls.usable_id(resource))
cls.echo('Desactivating probe on %s' % resource)
cls.display_progress(oper)
cls.echo('The probe have been desactivated')
return oper
|
[
"def",
"probe_disable",
"(",
"cls",
",",
"resource",
")",
":",
"oper",
"=",
"cls",
".",
"call",
"(",
"'hosting.rproxy.probe.disable'",
",",
"cls",
".",
"usable_id",
"(",
"resource",
")",
")",
"cls",
".",
"echo",
"(",
"'Desactivating probe on %s'",
"%",
"resource",
")",
"cls",
".",
"display_progress",
"(",
"oper",
")",
"cls",
".",
"echo",
"(",
"'The probe have been desactivated'",
")",
"return",
"oper"
] |
Disable a probe on a webaccelerator
|
[
"Disable",
"a",
"probe",
"on",
"a",
"webaccelerator"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L256-L263
|
11,210
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.usable_id
|
def usable_id(cls, id):
""" Retrieve id from input which can be hostname, vhost, id. """
try:
# id is maybe a hostname
qry_id = cls.from_name(id)
if not qry_id:
# id is maybe an ip
qry_id = cls.from_ip(id)
if not qry_id:
qry_id = cls.from_vhost(id)
except Exception:
qry_id = None
if not qry_id:
msg = 'unknown identifier %s' % id
cls.error(msg)
return qry_id
|
python
|
def usable_id(cls, id):
""" Retrieve id from input which can be hostname, vhost, id. """
try:
# id is maybe a hostname
qry_id = cls.from_name(id)
if not qry_id:
# id is maybe an ip
qry_id = cls.from_ip(id)
if not qry_id:
qry_id = cls.from_vhost(id)
except Exception:
qry_id = None
if not qry_id:
msg = 'unknown identifier %s' % id
cls.error(msg)
return qry_id
|
[
"def",
"usable_id",
"(",
"cls",
",",
"id",
")",
":",
"try",
":",
"# id is maybe a hostname",
"qry_id",
"=",
"cls",
".",
"from_name",
"(",
"id",
")",
"if",
"not",
"qry_id",
":",
"# id is maybe an ip",
"qry_id",
"=",
"cls",
".",
"from_ip",
"(",
"id",
")",
"if",
"not",
"qry_id",
":",
"qry_id",
"=",
"cls",
".",
"from_vhost",
"(",
"id",
")",
"except",
"Exception",
":",
"qry_id",
"=",
"None",
"if",
"not",
"qry_id",
":",
"msg",
"=",
"'unknown identifier %s'",
"%",
"id",
"cls",
".",
"error",
"(",
"msg",
")",
"return",
"qry_id"
] |
Retrieve id from input which can be hostname, vhost, id.
|
[
"Retrieve",
"id",
"from",
"input",
"which",
"can",
"be",
"hostname",
"vhost",
"id",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L266-L283
|
11,211
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.from_name
|
def from_name(cls, name):
"""Retrieve webacc id associated to a webacc name."""
result = cls.list({'items_per_page': 500})
webaccs = {}
for webacc in result:
webaccs[webacc['name']] = webacc['id']
return webaccs.get(name)
|
python
|
def from_name(cls, name):
"""Retrieve webacc id associated to a webacc name."""
result = cls.list({'items_per_page': 500})
webaccs = {}
for webacc in result:
webaccs[webacc['name']] = webacc['id']
return webaccs.get(name)
|
[
"def",
"from_name",
"(",
"cls",
",",
"name",
")",
":",
"result",
"=",
"cls",
".",
"list",
"(",
"{",
"'items_per_page'",
":",
"500",
"}",
")",
"webaccs",
"=",
"{",
"}",
"for",
"webacc",
"in",
"result",
":",
"webaccs",
"[",
"webacc",
"[",
"'name'",
"]",
"]",
"=",
"webacc",
"[",
"'id'",
"]",
"return",
"webaccs",
".",
"get",
"(",
"name",
")"
] |
Retrieve webacc id associated to a webacc name.
|
[
"Retrieve",
"webacc",
"id",
"associated",
"to",
"a",
"webacc",
"name",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L286-L292
|
11,212
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.from_ip
|
def from_ip(cls, ip):
"""Retrieve webacc id associated to a webacc ip"""
result = cls.list({'items_per_page': 500})
webaccs = {}
for webacc in result:
for server in webacc['servers']:
webaccs[server['ip']] = webacc['id']
return webaccs.get(ip)
|
python
|
def from_ip(cls, ip):
"""Retrieve webacc id associated to a webacc ip"""
result = cls.list({'items_per_page': 500})
webaccs = {}
for webacc in result:
for server in webacc['servers']:
webaccs[server['ip']] = webacc['id']
return webaccs.get(ip)
|
[
"def",
"from_ip",
"(",
"cls",
",",
"ip",
")",
":",
"result",
"=",
"cls",
".",
"list",
"(",
"{",
"'items_per_page'",
":",
"500",
"}",
")",
"webaccs",
"=",
"{",
"}",
"for",
"webacc",
"in",
"result",
":",
"for",
"server",
"in",
"webacc",
"[",
"'servers'",
"]",
":",
"webaccs",
"[",
"server",
"[",
"'ip'",
"]",
"]",
"=",
"webacc",
"[",
"'id'",
"]",
"return",
"webaccs",
".",
"get",
"(",
"ip",
")"
] |
Retrieve webacc id associated to a webacc ip
|
[
"Retrieve",
"webacc",
"id",
"associated",
"to",
"a",
"webacc",
"ip"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L295-L302
|
11,213
|
Gandi/gandi.cli
|
gandi/cli/modules/webacc.py
|
Webacc.from_vhost
|
def from_vhost(cls, vhost):
"""Retrieve webbacc id associated to a webacc vhost"""
result = cls.list({'items_per_page': 500})
webaccs = {}
for webacc in result:
for vhost in webacc['vhosts']:
webaccs[vhost['name']] = webacc['id']
return webaccs.get(vhost)
|
python
|
def from_vhost(cls, vhost):
"""Retrieve webbacc id associated to a webacc vhost"""
result = cls.list({'items_per_page': 500})
webaccs = {}
for webacc in result:
for vhost in webacc['vhosts']:
webaccs[vhost['name']] = webacc['id']
return webaccs.get(vhost)
|
[
"def",
"from_vhost",
"(",
"cls",
",",
"vhost",
")",
":",
"result",
"=",
"cls",
".",
"list",
"(",
"{",
"'items_per_page'",
":",
"500",
"}",
")",
"webaccs",
"=",
"{",
"}",
"for",
"webacc",
"in",
"result",
":",
"for",
"vhost",
"in",
"webacc",
"[",
"'vhosts'",
"]",
":",
"webaccs",
"[",
"vhost",
"[",
"'name'",
"]",
"]",
"=",
"webacc",
"[",
"'id'",
"]",
"return",
"webaccs",
".",
"get",
"(",
"vhost",
")"
] |
Retrieve webbacc id associated to a webacc vhost
|
[
"Retrieve",
"webbacc",
"id",
"associated",
"to",
"a",
"webacc",
"vhost"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/webacc.py#L305-L312
|
11,214
|
Gandi/gandi.cli
|
gandi/cli/modules/status.py
|
Status.descriptions
|
def descriptions(cls):
""" Retrieve status descriptions from status.gandi.net. """
schema = cls.json_get('%s/status/schema' % cls.api_url, empty_key=True,
send_key=False)
descs = {}
for val in schema['fields']['status']['value']:
descs.update(val)
return descs
|
python
|
def descriptions(cls):
""" Retrieve status descriptions from status.gandi.net. """
schema = cls.json_get('%s/status/schema' % cls.api_url, empty_key=True,
send_key=False)
descs = {}
for val in schema['fields']['status']['value']:
descs.update(val)
return descs
|
[
"def",
"descriptions",
"(",
"cls",
")",
":",
"schema",
"=",
"cls",
".",
"json_get",
"(",
"'%s/status/schema'",
"%",
"cls",
".",
"api_url",
",",
"empty_key",
"=",
"True",
",",
"send_key",
"=",
"False",
")",
"descs",
"=",
"{",
"}",
"for",
"val",
"in",
"schema",
"[",
"'fields'",
"]",
"[",
"'status'",
"]",
"[",
"'value'",
"]",
":",
"descs",
".",
"update",
"(",
"val",
")",
"return",
"descs"
] |
Retrieve status descriptions from status.gandi.net.
|
[
"Retrieve",
"status",
"descriptions",
"from",
"status",
".",
"gandi",
".",
"net",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/status.py#L23-L30
|
11,215
|
Gandi/gandi.cli
|
gandi/cli/modules/status.py
|
Status.services
|
def services(cls):
"""Retrieve services statuses from status.gandi.net."""
return cls.json_get('%s/services' % cls.api_url, empty_key=True,
send_key=False)
|
python
|
def services(cls):
"""Retrieve services statuses from status.gandi.net."""
return cls.json_get('%s/services' % cls.api_url, empty_key=True,
send_key=False)
|
[
"def",
"services",
"(",
"cls",
")",
":",
"return",
"cls",
".",
"json_get",
"(",
"'%s/services'",
"%",
"cls",
".",
"api_url",
",",
"empty_key",
"=",
"True",
",",
"send_key",
"=",
"False",
")"
] |
Retrieve services statuses from status.gandi.net.
|
[
"Retrieve",
"services",
"statuses",
"from",
"status",
".",
"gandi",
".",
"net",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/status.py#L33-L36
|
11,216
|
Gandi/gandi.cli
|
gandi/cli/modules/status.py
|
Status.status
|
def status(cls):
"""Retrieve global status from status.gandi.net."""
return cls.json_get('%s/status' % cls.api_url, empty_key=True,
send_key=False)
|
python
|
def status(cls):
"""Retrieve global status from status.gandi.net."""
return cls.json_get('%s/status' % cls.api_url, empty_key=True,
send_key=False)
|
[
"def",
"status",
"(",
"cls",
")",
":",
"return",
"cls",
".",
"json_get",
"(",
"'%s/status'",
"%",
"cls",
".",
"api_url",
",",
"empty_key",
"=",
"True",
",",
"send_key",
"=",
"False",
")"
] |
Retrieve global status from status.gandi.net.
|
[
"Retrieve",
"global",
"status",
"from",
"status",
".",
"gandi",
".",
"net",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/status.py#L39-L42
|
11,217
|
Gandi/gandi.cli
|
gandi/cli/modules/status.py
|
Status.events
|
def events(cls, filters):
"""Retrieve events details from status.gandi.net."""
current = filters.pop('current', False)
current_params = []
if current:
current_params = [('current', 'true')]
filter_url = uparse.urlencode(sorted(list(filters.items())) + current_params) # noqa
events = cls.json_get('%s/events?%s' % (cls.api_url, filter_url),
empty_key=True, send_key=False)
return events
|
python
|
def events(cls, filters):
"""Retrieve events details from status.gandi.net."""
current = filters.pop('current', False)
current_params = []
if current:
current_params = [('current', 'true')]
filter_url = uparse.urlencode(sorted(list(filters.items())) + current_params) # noqa
events = cls.json_get('%s/events?%s' % (cls.api_url, filter_url),
empty_key=True, send_key=False)
return events
|
[
"def",
"events",
"(",
"cls",
",",
"filters",
")",
":",
"current",
"=",
"filters",
".",
"pop",
"(",
"'current'",
",",
"False",
")",
"current_params",
"=",
"[",
"]",
"if",
"current",
":",
"current_params",
"=",
"[",
"(",
"'current'",
",",
"'true'",
")",
"]",
"filter_url",
"=",
"uparse",
".",
"urlencode",
"(",
"sorted",
"(",
"list",
"(",
"filters",
".",
"items",
"(",
")",
")",
")",
"+",
"current_params",
")",
"# noqa",
"events",
"=",
"cls",
".",
"json_get",
"(",
"'%s/events?%s'",
"%",
"(",
"cls",
".",
"api_url",
",",
"filter_url",
")",
",",
"empty_key",
"=",
"True",
",",
"send_key",
"=",
"False",
")",
"return",
"events"
] |
Retrieve events details from status.gandi.net.
|
[
"Retrieve",
"events",
"details",
"from",
"status",
".",
"gandi",
".",
"net",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/status.py#L45-L55
|
11,218
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
list
|
def list(gandi, state, id, vhosts, type, limit):
"""List PaaS instances."""
options = {
'items_per_page': limit,
}
if state:
options['state'] = state
output_keys = ['name', 'state']
if id:
output_keys.append('id')
if vhosts:
output_keys.append('vhost')
if type:
output_keys.append('type')
paas_hosts = {}
result = gandi.paas.list(options)
for num, paas in enumerate(result):
paas_hosts[paas['id']] = []
if vhosts:
list_vhost = gandi.vhost.list({'paas_id': paas['id']})
for host in list_vhost:
paas_hosts[paas['id']].append(host['name'])
if num:
gandi.separator_line()
output_paas(gandi, paas, [], paas_hosts[paas['id']],
output_keys)
return result
|
python
|
def list(gandi, state, id, vhosts, type, limit):
"""List PaaS instances."""
options = {
'items_per_page': limit,
}
if state:
options['state'] = state
output_keys = ['name', 'state']
if id:
output_keys.append('id')
if vhosts:
output_keys.append('vhost')
if type:
output_keys.append('type')
paas_hosts = {}
result = gandi.paas.list(options)
for num, paas in enumerate(result):
paas_hosts[paas['id']] = []
if vhosts:
list_vhost = gandi.vhost.list({'paas_id': paas['id']})
for host in list_vhost:
paas_hosts[paas['id']].append(host['name'])
if num:
gandi.separator_line()
output_paas(gandi, paas, [], paas_hosts[paas['id']],
output_keys)
return result
|
[
"def",
"list",
"(",
"gandi",
",",
"state",
",",
"id",
",",
"vhosts",
",",
"type",
",",
"limit",
")",
":",
"options",
"=",
"{",
"'items_per_page'",
":",
"limit",
",",
"}",
"if",
"state",
":",
"options",
"[",
"'state'",
"]",
"=",
"state",
"output_keys",
"=",
"[",
"'name'",
",",
"'state'",
"]",
"if",
"id",
":",
"output_keys",
".",
"append",
"(",
"'id'",
")",
"if",
"vhosts",
":",
"output_keys",
".",
"append",
"(",
"'vhost'",
")",
"if",
"type",
":",
"output_keys",
".",
"append",
"(",
"'type'",
")",
"paas_hosts",
"=",
"{",
"}",
"result",
"=",
"gandi",
".",
"paas",
".",
"list",
"(",
"options",
")",
"for",
"num",
",",
"paas",
"in",
"enumerate",
"(",
"result",
")",
":",
"paas_hosts",
"[",
"paas",
"[",
"'id'",
"]",
"]",
"=",
"[",
"]",
"if",
"vhosts",
":",
"list_vhost",
"=",
"gandi",
".",
"vhost",
".",
"list",
"(",
"{",
"'paas_id'",
":",
"paas",
"[",
"'id'",
"]",
"}",
")",
"for",
"host",
"in",
"list_vhost",
":",
"paas_hosts",
"[",
"paas",
"[",
"'id'",
"]",
"]",
".",
"append",
"(",
"host",
"[",
"'name'",
"]",
")",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"output_paas",
"(",
"gandi",
",",
"paas",
",",
"[",
"]",
",",
"paas_hosts",
"[",
"paas",
"[",
"'id'",
"]",
"]",
",",
"output_keys",
")",
"return",
"result"
] |
List PaaS instances.
|
[
"List",
"PaaS",
"instances",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L30-L60
|
11,219
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
info
|
def info(gandi, resource, stat):
"""Display information about a PaaS instance.
Resource can be a vhost, a hostname, or an ID
Cache statistics are based on 24 hours data.
"""
output_keys = ['name', 'type', 'size', 'memory', 'console', 'vhost',
'dc', 'sftp_server', 'git_server', 'snapshot']
paas = gandi.paas.info(resource)
paas_hosts = []
list_vhost = gandi.vhost.list({'paas_id': paas['id']})
df = gandi.paas.quota(paas['id'])
paas.update({'df': df})
if stat:
cache = gandi.paas.cache(paas['id'])
paas.update({'cache': cache})
for host in list_vhost:
paas_hosts.append(host['name'])
output_paas(gandi, paas, [], paas_hosts, output_keys)
return paas
|
python
|
def info(gandi, resource, stat):
"""Display information about a PaaS instance.
Resource can be a vhost, a hostname, or an ID
Cache statistics are based on 24 hours data.
"""
output_keys = ['name', 'type', 'size', 'memory', 'console', 'vhost',
'dc', 'sftp_server', 'git_server', 'snapshot']
paas = gandi.paas.info(resource)
paas_hosts = []
list_vhost = gandi.vhost.list({'paas_id': paas['id']})
df = gandi.paas.quota(paas['id'])
paas.update({'df': df})
if stat:
cache = gandi.paas.cache(paas['id'])
paas.update({'cache': cache})
for host in list_vhost:
paas_hosts.append(host['name'])
output_paas(gandi, paas, [], paas_hosts, output_keys)
return paas
|
[
"def",
"info",
"(",
"gandi",
",",
"resource",
",",
"stat",
")",
":",
"output_keys",
"=",
"[",
"'name'",
",",
"'type'",
",",
"'size'",
",",
"'memory'",
",",
"'console'",
",",
"'vhost'",
",",
"'dc'",
",",
"'sftp_server'",
",",
"'git_server'",
",",
"'snapshot'",
"]",
"paas",
"=",
"gandi",
".",
"paas",
".",
"info",
"(",
"resource",
")",
"paas_hosts",
"=",
"[",
"]",
"list_vhost",
"=",
"gandi",
".",
"vhost",
".",
"list",
"(",
"{",
"'paas_id'",
":",
"paas",
"[",
"'id'",
"]",
"}",
")",
"df",
"=",
"gandi",
".",
"paas",
".",
"quota",
"(",
"paas",
"[",
"'id'",
"]",
")",
"paas",
".",
"update",
"(",
"{",
"'df'",
":",
"df",
"}",
")",
"if",
"stat",
":",
"cache",
"=",
"gandi",
".",
"paas",
".",
"cache",
"(",
"paas",
"[",
"'id'",
"]",
")",
"paas",
".",
"update",
"(",
"{",
"'cache'",
":",
"cache",
"}",
")",
"for",
"host",
"in",
"list_vhost",
":",
"paas_hosts",
".",
"append",
"(",
"host",
"[",
"'name'",
"]",
")",
"output_paas",
"(",
"gandi",
",",
"paas",
",",
"[",
"]",
",",
"paas_hosts",
",",
"output_keys",
")",
"return",
"paas"
] |
Display information about a PaaS instance.
Resource can be a vhost, a hostname, or an ID
Cache statistics are based on 24 hours data.
|
[
"Display",
"information",
"about",
"a",
"PaaS",
"instance",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L68-L93
|
11,220
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
clone
|
def clone(gandi, name, vhost, directory, origin):
"""Clone a remote vhost in a local git repository."""
if vhost != 'default':
directory = vhost
else:
directory = name if not directory else directory
return gandi.paas.clone(name, vhost, directory, origin)
|
python
|
def clone(gandi, name, vhost, directory, origin):
"""Clone a remote vhost in a local git repository."""
if vhost != 'default':
directory = vhost
else:
directory = name if not directory else directory
return gandi.paas.clone(name, vhost, directory, origin)
|
[
"def",
"clone",
"(",
"gandi",
",",
"name",
",",
"vhost",
",",
"directory",
",",
"origin",
")",
":",
"if",
"vhost",
"!=",
"'default'",
":",
"directory",
"=",
"vhost",
"else",
":",
"directory",
"=",
"name",
"if",
"not",
"directory",
"else",
"directory",
"return",
"gandi",
".",
"paas",
".",
"clone",
"(",
"name",
",",
"vhost",
",",
"directory",
",",
"origin",
")"
] |
Clone a remote vhost in a local git repository.
|
[
"Clone",
"a",
"remote",
"vhost",
"in",
"a",
"local",
"git",
"repository",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L102-L109
|
11,221
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
attach
|
def attach(gandi, name, vhost, remote):
"""Add remote for an instance's default vhost to the local git repository.
"""
return gandi.paas.attach(name, vhost, remote)
|
python
|
def attach(gandi, name, vhost, remote):
"""Add remote for an instance's default vhost to the local git repository.
"""
return gandi.paas.attach(name, vhost, remote)
|
[
"def",
"attach",
"(",
"gandi",
",",
"name",
",",
"vhost",
",",
"remote",
")",
":",
"return",
"gandi",
".",
"paas",
".",
"attach",
"(",
"name",
",",
"vhost",
",",
"remote",
")"
] |
Add remote for an instance's default vhost to the local git repository.
|
[
"Add",
"remote",
"for",
"an",
"instance",
"s",
"default",
"vhost",
"to",
"the",
"local",
"git",
"repository",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L119-L122
|
11,222
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
create
|
def create(gandi, name, size, type, quantity, duration, datacenter, vhosts,
password, snapshotprofile, background, sshkey, ssl, private_key,
poll_cert):
"""Create a new PaaS instance and initialize associated git repository.
you can specify a configuration entry named 'sshkey' containing
path to your sshkey file
$ gandi config set [-g] sshkey ~/.ssh/id_rsa.pub
or getting the sshkey "my_key" from your gandi ssh keyring
$ gandi config set [-g] sshkey my_key
to know which PaaS instance type to use as type
$ gandi paas types
"""
try:
gandi.datacenter.is_opened(datacenter, 'paas')
except DatacenterLimited as exc:
gandi.echo('/!\ Datacenter %s will be closed on %s, '
'please consider using another datacenter.' %
(datacenter, exc.date))
if not password:
password = click.prompt('password', hide_input=True,
confirmation_prompt=True)
if not name:
name = randomstring('paas')
if vhosts and not gandi.hostedcert.activate_ssl(vhosts,
ssl,
private_key,
poll_cert):
return
result = gandi.paas.create(name, size, type, quantity, duration,
datacenter, vhosts, password,
snapshotprofile, background, sshkey)
return result
|
python
|
def create(gandi, name, size, type, quantity, duration, datacenter, vhosts,
password, snapshotprofile, background, sshkey, ssl, private_key,
poll_cert):
"""Create a new PaaS instance and initialize associated git repository.
you can specify a configuration entry named 'sshkey' containing
path to your sshkey file
$ gandi config set [-g] sshkey ~/.ssh/id_rsa.pub
or getting the sshkey "my_key" from your gandi ssh keyring
$ gandi config set [-g] sshkey my_key
to know which PaaS instance type to use as type
$ gandi paas types
"""
try:
gandi.datacenter.is_opened(datacenter, 'paas')
except DatacenterLimited as exc:
gandi.echo('/!\ Datacenter %s will be closed on %s, '
'please consider using another datacenter.' %
(datacenter, exc.date))
if not password:
password = click.prompt('password', hide_input=True,
confirmation_prompt=True)
if not name:
name = randomstring('paas')
if vhosts and not gandi.hostedcert.activate_ssl(vhosts,
ssl,
private_key,
poll_cert):
return
result = gandi.paas.create(name, size, type, quantity, duration,
datacenter, vhosts, password,
snapshotprofile, background, sshkey)
return result
|
[
"def",
"create",
"(",
"gandi",
",",
"name",
",",
"size",
",",
"type",
",",
"quantity",
",",
"duration",
",",
"datacenter",
",",
"vhosts",
",",
"password",
",",
"snapshotprofile",
",",
"background",
",",
"sshkey",
",",
"ssl",
",",
"private_key",
",",
"poll_cert",
")",
":",
"try",
":",
"gandi",
".",
"datacenter",
".",
"is_opened",
"(",
"datacenter",
",",
"'paas'",
")",
"except",
"DatacenterLimited",
"as",
"exc",
":",
"gandi",
".",
"echo",
"(",
"'/!\\ Datacenter %s will be closed on %s, '",
"'please consider using another datacenter.'",
"%",
"(",
"datacenter",
",",
"exc",
".",
"date",
")",
")",
"if",
"not",
"password",
":",
"password",
"=",
"click",
".",
"prompt",
"(",
"'password'",
",",
"hide_input",
"=",
"True",
",",
"confirmation_prompt",
"=",
"True",
")",
"if",
"not",
"name",
":",
"name",
"=",
"randomstring",
"(",
"'paas'",
")",
"if",
"vhosts",
"and",
"not",
"gandi",
".",
"hostedcert",
".",
"activate_ssl",
"(",
"vhosts",
",",
"ssl",
",",
"private_key",
",",
"poll_cert",
")",
":",
"return",
"result",
"=",
"gandi",
".",
"paas",
".",
"create",
"(",
"name",
",",
"size",
",",
"type",
",",
"quantity",
",",
"duration",
",",
"datacenter",
",",
"vhosts",
",",
"password",
",",
"snapshotprofile",
",",
"background",
",",
"sshkey",
")",
"return",
"result"
] |
Create a new PaaS instance and initialize associated git repository.
you can specify a configuration entry named 'sshkey' containing
path to your sshkey file
$ gandi config set [-g] sshkey ~/.ssh/id_rsa.pub
or getting the sshkey "my_key" from your gandi ssh keyring
$ gandi config set [-g] sshkey my_key
to know which PaaS instance type to use as type
$ gandi paas types
|
[
"Create",
"a",
"new",
"PaaS",
"instance",
"and",
"initialize",
"associated",
"git",
"repository",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L207-L249
|
11,223
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
restart
|
def restart(gandi, resource, background, force):
"""Restart a PaaS instance.
Resource can be a vhost, a hostname, or an ID
"""
output_keys = ['id', 'type', 'step']
possible_resources = gandi.paas.resource_list()
for item in resource:
if item not in possible_resources:
gandi.echo('Sorry PaaS instance %s does not exist' % item)
gandi.echo('Please use one of the following: %s' %
possible_resources)
return
if not force:
instance_info = "'%s'" % ', '.join(resource)
proceed = click.confirm("Are you sure to restart PaaS instance %s?" %
instance_info)
if not proceed:
return
opers = gandi.paas.restart(resource, background)
if background:
for oper in opers:
output_generic(gandi, oper, output_keys)
return opers
|
python
|
def restart(gandi, resource, background, force):
"""Restart a PaaS instance.
Resource can be a vhost, a hostname, or an ID
"""
output_keys = ['id', 'type', 'step']
possible_resources = gandi.paas.resource_list()
for item in resource:
if item not in possible_resources:
gandi.echo('Sorry PaaS instance %s does not exist' % item)
gandi.echo('Please use one of the following: %s' %
possible_resources)
return
if not force:
instance_info = "'%s'" % ', '.join(resource)
proceed = click.confirm("Are you sure to restart PaaS instance %s?" %
instance_info)
if not proceed:
return
opers = gandi.paas.restart(resource, background)
if background:
for oper in opers:
output_generic(gandi, oper, output_keys)
return opers
|
[
"def",
"restart",
"(",
"gandi",
",",
"resource",
",",
"background",
",",
"force",
")",
":",
"output_keys",
"=",
"[",
"'id'",
",",
"'type'",
",",
"'step'",
"]",
"possible_resources",
"=",
"gandi",
".",
"paas",
".",
"resource_list",
"(",
")",
"for",
"item",
"in",
"resource",
":",
"if",
"item",
"not",
"in",
"possible_resources",
":",
"gandi",
".",
"echo",
"(",
"'Sorry PaaS instance %s does not exist'",
"%",
"item",
")",
"gandi",
".",
"echo",
"(",
"'Please use one of the following: %s'",
"%",
"possible_resources",
")",
"return",
"if",
"not",
"force",
":",
"instance_info",
"=",
"\"'%s'\"",
"%",
"', '",
".",
"join",
"(",
"resource",
")",
"proceed",
"=",
"click",
".",
"confirm",
"(",
"\"Are you sure to restart PaaS instance %s?\"",
"%",
"instance_info",
")",
"if",
"not",
"proceed",
":",
"return",
"opers",
"=",
"gandi",
".",
"paas",
".",
"restart",
"(",
"resource",
",",
"background",
")",
"if",
"background",
":",
"for",
"oper",
"in",
"opers",
":",
"output_generic",
"(",
"gandi",
",",
"oper",
",",
"output_keys",
")",
"return",
"opers"
] |
Restart a PaaS instance.
Resource can be a vhost, a hostname, or an ID
|
[
"Restart",
"a",
"PaaS",
"instance",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L315-L343
|
11,224
|
Gandi/gandi.cli
|
gandi/cli/commands/paas.py
|
types
|
def types(gandi):
"""List types PaaS instances."""
options = {}
types = gandi.paas.type_list(options)
for type_ in types:
gandi.echo(type_['name'])
return types
|
python
|
def types(gandi):
"""List types PaaS instances."""
options = {}
types = gandi.paas.type_list(options)
for type_ in types:
gandi.echo(type_['name'])
return types
|
[
"def",
"types",
"(",
"gandi",
")",
":",
"options",
"=",
"{",
"}",
"types",
"=",
"gandi",
".",
"paas",
".",
"type_list",
"(",
"options",
")",
"for",
"type_",
"in",
"types",
":",
"gandi",
".",
"echo",
"(",
"type_",
"[",
"'name'",
"]",
")",
"return",
"types"
] |
List types PaaS instances.
|
[
"List",
"types",
"PaaS",
"instances",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/paas.py#L348-L355
|
11,225
|
Gandi/gandi.cli
|
gandi/cli/commands/sshkey.py
|
info
|
def info(gandi, resource, id, value):
"""Display information about an SSH key.
Resource can be a name or an ID
"""
output_keys = ['name', 'fingerprint']
if id:
output_keys.append('id')
if value:
output_keys.append('value')
ret = []
for item in resource:
sshkey = gandi.sshkey.info(item)
ret.append(output_sshkey(gandi, sshkey, output_keys))
return ret
|
python
|
def info(gandi, resource, id, value):
"""Display information about an SSH key.
Resource can be a name or an ID
"""
output_keys = ['name', 'fingerprint']
if id:
output_keys.append('id')
if value:
output_keys.append('value')
ret = []
for item in resource:
sshkey = gandi.sshkey.info(item)
ret.append(output_sshkey(gandi, sshkey, output_keys))
return ret
|
[
"def",
"info",
"(",
"gandi",
",",
"resource",
",",
"id",
",",
"value",
")",
":",
"output_keys",
"=",
"[",
"'name'",
",",
"'fingerprint'",
"]",
"if",
"id",
":",
"output_keys",
".",
"append",
"(",
"'id'",
")",
"if",
"value",
":",
"output_keys",
".",
"append",
"(",
"'value'",
")",
"ret",
"=",
"[",
"]",
"for",
"item",
"in",
"resource",
":",
"sshkey",
"=",
"gandi",
".",
"sshkey",
".",
"info",
"(",
"item",
")",
"ret",
".",
"append",
"(",
"output_sshkey",
"(",
"gandi",
",",
"sshkey",
",",
"output_keys",
")",
")",
"return",
"ret"
] |
Display information about an SSH key.
Resource can be a name or an ID
|
[
"Display",
"information",
"about",
"an",
"SSH",
"key",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/sshkey.py#L47-L64
|
11,226
|
Gandi/gandi.cli
|
gandi/cli/commands/sshkey.py
|
create
|
def create(gandi, name, value=None, filename=None):
""" Create a new SSH key. """
if not value and not filename:
raise UsageError('You must set value OR filename.')
if value and filename:
raise UsageError('You must not set value AND filename.')
if filename:
value = filename.read()
ret = gandi.sshkey.create(name, value)
output_keys = ['id', 'name', 'fingerprint']
return output_sshkey(gandi, ret, output_keys)
|
python
|
def create(gandi, name, value=None, filename=None):
""" Create a new SSH key. """
if not value and not filename:
raise UsageError('You must set value OR filename.')
if value and filename:
raise UsageError('You must not set value AND filename.')
if filename:
value = filename.read()
ret = gandi.sshkey.create(name, value)
output_keys = ['id', 'name', 'fingerprint']
return output_sshkey(gandi, ret, output_keys)
|
[
"def",
"create",
"(",
"gandi",
",",
"name",
",",
"value",
"=",
"None",
",",
"filename",
"=",
"None",
")",
":",
"if",
"not",
"value",
"and",
"not",
"filename",
":",
"raise",
"UsageError",
"(",
"'You must set value OR filename.'",
")",
"if",
"value",
"and",
"filename",
":",
"raise",
"UsageError",
"(",
"'You must not set value AND filename.'",
")",
"if",
"filename",
":",
"value",
"=",
"filename",
".",
"read",
"(",
")",
"ret",
"=",
"gandi",
".",
"sshkey",
".",
"create",
"(",
"name",
",",
"value",
")",
"output_keys",
"=",
"[",
"'id'",
",",
"'name'",
",",
"'fingerprint'",
"]",
"return",
"output_sshkey",
"(",
"gandi",
",",
"ret",
",",
"output_keys",
")"
] |
Create a new SSH key.
|
[
"Create",
"a",
"new",
"SSH",
"key",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/sshkey.py#L72-L86
|
11,227
|
Gandi/gandi.cli
|
gandi/cli/modules/account.py
|
Account.creditusage
|
def creditusage(cls):
"""Get credit usage per hour"""
rating = cls.call('hosting.rating.list')
if not rating:
return 0
rating = rating.pop()
usage = [sum(resource.values())
for resource in rating.values()
if isinstance(resource, dict)]
return sum(usage)
|
python
|
def creditusage(cls):
"""Get credit usage per hour"""
rating = cls.call('hosting.rating.list')
if not rating:
return 0
rating = rating.pop()
usage = [sum(resource.values())
for resource in rating.values()
if isinstance(resource, dict)]
return sum(usage)
|
[
"def",
"creditusage",
"(",
"cls",
")",
":",
"rating",
"=",
"cls",
".",
"call",
"(",
"'hosting.rating.list'",
")",
"if",
"not",
"rating",
":",
"return",
"0",
"rating",
"=",
"rating",
".",
"pop",
"(",
")",
"usage",
"=",
"[",
"sum",
"(",
"resource",
".",
"values",
"(",
")",
")",
"for",
"resource",
"in",
"rating",
".",
"values",
"(",
")",
"if",
"isinstance",
"(",
"resource",
",",
"dict",
")",
"]",
"return",
"sum",
"(",
"usage",
")"
] |
Get credit usage per hour
|
[
"Get",
"credit",
"usage",
"per",
"hour"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/account.py#L20-L30
|
11,228
|
Gandi/gandi.cli
|
gandi/cli/modules/account.py
|
Account.all
|
def all(cls):
""" Get all informations about this account """
account = cls.info()
creditusage = cls.creditusage()
if not creditusage:
return account
left = account['credits'] / creditusage
years, hours = divmod(left, 365 * 24)
months, hours = divmod(hours, 31 * 24)
days, hours = divmod(hours, 24)
account.update({'credit_usage': creditusage,
'left': (years, months, days, hours)})
return account
|
python
|
def all(cls):
""" Get all informations about this account """
account = cls.info()
creditusage = cls.creditusage()
if not creditusage:
return account
left = account['credits'] / creditusage
years, hours = divmod(left, 365 * 24)
months, hours = divmod(hours, 31 * 24)
days, hours = divmod(hours, 24)
account.update({'credit_usage': creditusage,
'left': (years, months, days, hours)})
return account
|
[
"def",
"all",
"(",
"cls",
")",
":",
"account",
"=",
"cls",
".",
"info",
"(",
")",
"creditusage",
"=",
"cls",
".",
"creditusage",
"(",
")",
"if",
"not",
"creditusage",
":",
"return",
"account",
"left",
"=",
"account",
"[",
"'credits'",
"]",
"/",
"creditusage",
"years",
",",
"hours",
"=",
"divmod",
"(",
"left",
",",
"365",
"*",
"24",
")",
"months",
",",
"hours",
"=",
"divmod",
"(",
"hours",
",",
"31",
"*",
"24",
")",
"days",
",",
"hours",
"=",
"divmod",
"(",
"hours",
",",
"24",
")",
"account",
".",
"update",
"(",
"{",
"'credit_usage'",
":",
"creditusage",
",",
"'left'",
":",
"(",
"years",
",",
"months",
",",
"days",
",",
"hours",
")",
"}",
")",
"return",
"account"
] |
Get all informations about this account
|
[
"Get",
"all",
"informations",
"about",
"this",
"account"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/account.py#L33-L49
|
11,229
|
Gandi/gandi.cli
|
gandi/cli/commands/snapshotprofile.py
|
list
|
def list(gandi, only_paas, only_vm):
""" List snapshot profiles. """
target = None
if only_paas and not only_vm:
target = 'paas'
if only_vm and not only_paas:
target = 'vm'
output_keys = ['id', 'name', 'kept_total', 'target']
result = gandi.snapshotprofile.list({}, target=target)
for num, profile in enumerate(result):
if num:
gandi.separator_line()
output_snapshot_profile(gandi, profile, output_keys)
return result
|
python
|
def list(gandi, only_paas, only_vm):
""" List snapshot profiles. """
target = None
if only_paas and not only_vm:
target = 'paas'
if only_vm and not only_paas:
target = 'vm'
output_keys = ['id', 'name', 'kept_total', 'target']
result = gandi.snapshotprofile.list({}, target=target)
for num, profile in enumerate(result):
if num:
gandi.separator_line()
output_snapshot_profile(gandi, profile, output_keys)
return result
|
[
"def",
"list",
"(",
"gandi",
",",
"only_paas",
",",
"only_vm",
")",
":",
"target",
"=",
"None",
"if",
"only_paas",
"and",
"not",
"only_vm",
":",
"target",
"=",
"'paas'",
"if",
"only_vm",
"and",
"not",
"only_paas",
":",
"target",
"=",
"'vm'",
"output_keys",
"=",
"[",
"'id'",
",",
"'name'",
",",
"'kept_total'",
",",
"'target'",
"]",
"result",
"=",
"gandi",
".",
"snapshotprofile",
".",
"list",
"(",
"{",
"}",
",",
"target",
"=",
"target",
")",
"for",
"num",
",",
"profile",
"in",
"enumerate",
"(",
"result",
")",
":",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"output_snapshot_profile",
"(",
"gandi",
",",
"profile",
",",
"output_keys",
")",
"return",
"result"
] |
List snapshot profiles.
|
[
"List",
"snapshot",
"profiles",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/snapshotprofile.py#L20-L36
|
11,230
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
list
|
def list(gandi, id, altnames, csr, cert, all_status, status, dates, limit):
""" List certificates. """
options = {'items_per_page': limit}
if not all_status:
options['status'] = ['valid', 'pending']
output_keys = ['cn', 'plan']
if id:
output_keys.append('id')
if status:
output_keys.append('status')
if dates:
output_keys.extend(['date_created', 'date_end'])
if altnames:
output_keys.append('altnames')
if csr:
output_keys.append('csr')
if cert:
output_keys.append('cert')
result = gandi.certificate.list(options)
for num, cert in enumerate(result):
if num:
gandi.separator_line()
cert['plan'] = package_desc(gandi, cert['package'])
output_cert(gandi, cert, output_keys)
return result
|
python
|
def list(gandi, id, altnames, csr, cert, all_status, status, dates, limit):
""" List certificates. """
options = {'items_per_page': limit}
if not all_status:
options['status'] = ['valid', 'pending']
output_keys = ['cn', 'plan']
if id:
output_keys.append('id')
if status:
output_keys.append('status')
if dates:
output_keys.extend(['date_created', 'date_end'])
if altnames:
output_keys.append('altnames')
if csr:
output_keys.append('csr')
if cert:
output_keys.append('cert')
result = gandi.certificate.list(options)
for num, cert in enumerate(result):
if num:
gandi.separator_line()
cert['plan'] = package_desc(gandi, cert['package'])
output_cert(gandi, cert, output_keys)
return result
|
[
"def",
"list",
"(",
"gandi",
",",
"id",
",",
"altnames",
",",
"csr",
",",
"cert",
",",
"all_status",
",",
"status",
",",
"dates",
",",
"limit",
")",
":",
"options",
"=",
"{",
"'items_per_page'",
":",
"limit",
"}",
"if",
"not",
"all_status",
":",
"options",
"[",
"'status'",
"]",
"=",
"[",
"'valid'",
",",
"'pending'",
"]",
"output_keys",
"=",
"[",
"'cn'",
",",
"'plan'",
"]",
"if",
"id",
":",
"output_keys",
".",
"append",
"(",
"'id'",
")",
"if",
"status",
":",
"output_keys",
".",
"append",
"(",
"'status'",
")",
"if",
"dates",
":",
"output_keys",
".",
"extend",
"(",
"[",
"'date_created'",
",",
"'date_end'",
"]",
")",
"if",
"altnames",
":",
"output_keys",
".",
"append",
"(",
"'altnames'",
")",
"if",
"csr",
":",
"output_keys",
".",
"append",
"(",
"'csr'",
")",
"if",
"cert",
":",
"output_keys",
".",
"append",
"(",
"'cert'",
")",
"result",
"=",
"gandi",
".",
"certificate",
".",
"list",
"(",
"options",
")",
"for",
"num",
",",
"cert",
"in",
"enumerate",
"(",
"result",
")",
":",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"cert",
"[",
"'plan'",
"]",
"=",
"package_desc",
"(",
"gandi",
",",
"cert",
"[",
"'package'",
"]",
")",
"output_cert",
"(",
"gandi",
",",
"cert",
",",
"output_keys",
")",
"return",
"result"
] |
List certificates.
|
[
"List",
"certificates",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L114-L148
|
11,231
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
info
|
def info(gandi, resource, id, altnames, csr, cert, all_status):
""" Display information about a certificate.
Resource can be a CN or an ID
"""
output_keys = ['cn', 'date_created', 'date_end', 'plan', 'status']
if id:
output_keys.append('id')
if altnames:
output_keys.append('altnames')
if csr:
output_keys.append('csr')
if cert:
output_keys.append('cert')
ids = []
for res in resource:
ids.extend(gandi.certificate.usable_ids(res))
result = []
for num, id_ in enumerate(set(ids)):
cert = gandi.certificate.info(id_)
if not all_status and cert['status'] not in ['valid', 'pending']:
continue
if num:
gandi.separator_line()
cert['plan'] = package_desc(gandi, cert['package'])
output_cert(gandi, cert, output_keys)
result.append(cert)
return result
|
python
|
def info(gandi, resource, id, altnames, csr, cert, all_status):
""" Display information about a certificate.
Resource can be a CN or an ID
"""
output_keys = ['cn', 'date_created', 'date_end', 'plan', 'status']
if id:
output_keys.append('id')
if altnames:
output_keys.append('altnames')
if csr:
output_keys.append('csr')
if cert:
output_keys.append('cert')
ids = []
for res in resource:
ids.extend(gandi.certificate.usable_ids(res))
result = []
for num, id_ in enumerate(set(ids)):
cert = gandi.certificate.info(id_)
if not all_status and cert['status'] not in ['valid', 'pending']:
continue
if num:
gandi.separator_line()
cert['plan'] = package_desc(gandi, cert['package'])
output_cert(gandi, cert, output_keys)
result.append(cert)
return result
|
[
"def",
"info",
"(",
"gandi",
",",
"resource",
",",
"id",
",",
"altnames",
",",
"csr",
",",
"cert",
",",
"all_status",
")",
":",
"output_keys",
"=",
"[",
"'cn'",
",",
"'date_created'",
",",
"'date_end'",
",",
"'plan'",
",",
"'status'",
"]",
"if",
"id",
":",
"output_keys",
".",
"append",
"(",
"'id'",
")",
"if",
"altnames",
":",
"output_keys",
".",
"append",
"(",
"'altnames'",
")",
"if",
"csr",
":",
"output_keys",
".",
"append",
"(",
"'csr'",
")",
"if",
"cert",
":",
"output_keys",
".",
"append",
"(",
"'cert'",
")",
"ids",
"=",
"[",
"]",
"for",
"res",
"in",
"resource",
":",
"ids",
".",
"extend",
"(",
"gandi",
".",
"certificate",
".",
"usable_ids",
"(",
"res",
")",
")",
"result",
"=",
"[",
"]",
"for",
"num",
",",
"id_",
"in",
"enumerate",
"(",
"set",
"(",
"ids",
")",
")",
":",
"cert",
"=",
"gandi",
".",
"certificate",
".",
"info",
"(",
"id_",
")",
"if",
"not",
"all_status",
"and",
"cert",
"[",
"'status'",
"]",
"not",
"in",
"[",
"'valid'",
",",
"'pending'",
"]",
":",
"continue",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"cert",
"[",
"'plan'",
"]",
"=",
"package_desc",
"(",
"gandi",
",",
"cert",
"[",
"'package'",
"]",
")",
"output_cert",
"(",
"gandi",
",",
"cert",
",",
"output_keys",
")",
"result",
".",
"append",
"(",
"cert",
")",
"return",
"result"
] |
Display information about a certificate.
Resource can be a CN or an ID
|
[
"Display",
"information",
"about",
"a",
"certificate",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L159-L193
|
11,232
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
update
|
def update(gandi, resource, csr, private_key, country, state, city,
organisation, branch, altnames, dcv_method):
""" Update a certificate CSR.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not update, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
id_ = ids[0]
result = gandi.certificate.update(id_, csr, private_key, country, state,
city, organisation, branch, altnames,
dcv_method)
gandi.echo('The certificate update operation is %s' % result['id'])
gandi.echo('You can follow it with:')
gandi.echo('$ gandi certificate follow %s' % result['id'])
gandi.echo('When the operation is DONE, you can retrieve the .crt'
' with:')
gandi.echo('$ gandi certificate export "%s"' % resource)
return result
|
python
|
def update(gandi, resource, csr, private_key, country, state, city,
organisation, branch, altnames, dcv_method):
""" Update a certificate CSR.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not update, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
id_ = ids[0]
result = gandi.certificate.update(id_, csr, private_key, country, state,
city, organisation, branch, altnames,
dcv_method)
gandi.echo('The certificate update operation is %s' % result['id'])
gandi.echo('You can follow it with:')
gandi.echo('$ gandi certificate follow %s' % result['id'])
gandi.echo('When the operation is DONE, you can retrieve the .crt'
' with:')
gandi.echo('$ gandi certificate export "%s"' % resource)
return result
|
[
"def",
"update",
"(",
"gandi",
",",
"resource",
",",
"csr",
",",
"private_key",
",",
"country",
",",
"state",
",",
"city",
",",
"organisation",
",",
"branch",
",",
"altnames",
",",
"dcv_method",
")",
":",
"ids",
"=",
"gandi",
".",
"certificate",
".",
"usable_ids",
"(",
"resource",
")",
"if",
"len",
"(",
"ids",
")",
">",
"1",
":",
"gandi",
".",
"echo",
"(",
"'Will not update, %s is not precise enough.'",
"%",
"resource",
")",
"gandi",
".",
"echo",
"(",
"' * cert : '",
"+",
"'\\n * cert : '",
".",
"join",
"(",
"[",
"str",
"(",
"id_",
")",
"for",
"id_",
"in",
"ids",
"]",
")",
")",
"return",
"id_",
"=",
"ids",
"[",
"0",
"]",
"result",
"=",
"gandi",
".",
"certificate",
".",
"update",
"(",
"id_",
",",
"csr",
",",
"private_key",
",",
"country",
",",
"state",
",",
"city",
",",
"organisation",
",",
"branch",
",",
"altnames",
",",
"dcv_method",
")",
"gandi",
".",
"echo",
"(",
"'The certificate update operation is %s'",
"%",
"result",
"[",
"'id'",
"]",
")",
"gandi",
".",
"echo",
"(",
"'You can follow it with:'",
")",
"gandi",
".",
"echo",
"(",
"'$ gandi certificate follow %s'",
"%",
"result",
"[",
"'id'",
"]",
")",
"gandi",
".",
"echo",
"(",
"'When the operation is DONE, you can retrieve the .crt'",
"' with:'",
")",
"gandi",
".",
"echo",
"(",
"'$ gandi certificate export \"%s\"'",
"%",
"resource",
")",
"return",
"result"
] |
Update a certificate CSR.
Resource can be a CN or an ID
|
[
"Update",
"a",
"certificate",
"CSR",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L389-L416
|
11,233
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
follow
|
def follow(gandi, resource):
""" Get the operation status
Resource is an operation ID
"""
oper = gandi.oper.info(int(resource))
assert(oper['type'].startswith('certificate_'))
output_cert_oper(gandi, oper)
return oper
|
python
|
def follow(gandi, resource):
""" Get the operation status
Resource is an operation ID
"""
oper = gandi.oper.info(int(resource))
assert(oper['type'].startswith('certificate_'))
output_cert_oper(gandi, oper)
return oper
|
[
"def",
"follow",
"(",
"gandi",
",",
"resource",
")",
":",
"oper",
"=",
"gandi",
".",
"oper",
".",
"info",
"(",
"int",
"(",
"resource",
")",
")",
"assert",
"(",
"oper",
"[",
"'type'",
"]",
".",
"startswith",
"(",
"'certificate_'",
")",
")",
"output_cert_oper",
"(",
"gandi",
",",
"oper",
")",
"return",
"oper"
] |
Get the operation status
Resource is an operation ID
|
[
"Get",
"the",
"operation",
"status"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L422-L430
|
11,234
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
change_dcv
|
def change_dcv(gandi, resource, dcv_method):
""" Change the DCV for a running certificate operation.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not update, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
id_ = ids[0]
opers = gandi.oper.list({'cert_id': id_})
if not opers:
gandi.echo('Can not find any operation for this certificate.')
return
oper = opers[0]
if (oper['step'] != 'RUN'
and oper['params']['inner_step'] != 'comodo_oper_updated'):
gandi.echo('This certificate operation is not in the good step to '
'update the DCV method.')
return
gandi.certificate.change_dcv(oper['id'], dcv_method)
cert = gandi.certificate.info(id_)
csr = oper['params']['csr']
package = cert['package']
altnames = oper['params'].get('altnames')
gandi.certificate.advice_dcv_method(csr, package, altnames, dcv_method,
cert_id=id_)
|
python
|
def change_dcv(gandi, resource, dcv_method):
""" Change the DCV for a running certificate operation.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not update, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
id_ = ids[0]
opers = gandi.oper.list({'cert_id': id_})
if not opers:
gandi.echo('Can not find any operation for this certificate.')
return
oper = opers[0]
if (oper['step'] != 'RUN'
and oper['params']['inner_step'] != 'comodo_oper_updated'):
gandi.echo('This certificate operation is not in the good step to '
'update the DCV method.')
return
gandi.certificate.change_dcv(oper['id'], dcv_method)
cert = gandi.certificate.info(id_)
csr = oper['params']['csr']
package = cert['package']
altnames = oper['params'].get('altnames')
gandi.certificate.advice_dcv_method(csr, package, altnames, dcv_method,
cert_id=id_)
|
[
"def",
"change_dcv",
"(",
"gandi",
",",
"resource",
",",
"dcv_method",
")",
":",
"ids",
"=",
"gandi",
".",
"certificate",
".",
"usable_ids",
"(",
"resource",
")",
"if",
"len",
"(",
"ids",
")",
">",
"1",
":",
"gandi",
".",
"echo",
"(",
"'Will not update, %s is not precise enough.'",
"%",
"resource",
")",
"gandi",
".",
"echo",
"(",
"' * cert : '",
"+",
"'\\n * cert : '",
".",
"join",
"(",
"[",
"str",
"(",
"id_",
")",
"for",
"id_",
"in",
"ids",
"]",
")",
")",
"return",
"id_",
"=",
"ids",
"[",
"0",
"]",
"opers",
"=",
"gandi",
".",
"oper",
".",
"list",
"(",
"{",
"'cert_id'",
":",
"id_",
"}",
")",
"if",
"not",
"opers",
":",
"gandi",
".",
"echo",
"(",
"'Can not find any operation for this certificate.'",
")",
"return",
"oper",
"=",
"opers",
"[",
"0",
"]",
"if",
"(",
"oper",
"[",
"'step'",
"]",
"!=",
"'RUN'",
"and",
"oper",
"[",
"'params'",
"]",
"[",
"'inner_step'",
"]",
"!=",
"'comodo_oper_updated'",
")",
":",
"gandi",
".",
"echo",
"(",
"'This certificate operation is not in the good step to '",
"'update the DCV method.'",
")",
"return",
"gandi",
".",
"certificate",
".",
"change_dcv",
"(",
"oper",
"[",
"'id'",
"]",
",",
"dcv_method",
")",
"cert",
"=",
"gandi",
".",
"certificate",
".",
"info",
"(",
"id_",
")",
"csr",
"=",
"oper",
"[",
"'params'",
"]",
"[",
"'csr'",
"]",
"package",
"=",
"cert",
"[",
"'package'",
"]",
"altnames",
"=",
"oper",
"[",
"'params'",
"]",
".",
"get",
"(",
"'altnames'",
")",
"gandi",
".",
"certificate",
".",
"advice_dcv_method",
"(",
"csr",
",",
"package",
",",
"altnames",
",",
"dcv_method",
",",
"cert_id",
"=",
"id_",
")"
] |
Change the DCV for a running certificate operation.
Resource can be a CN or an ID
|
[
"Change",
"the",
"DCV",
"for",
"a",
"running",
"certificate",
"operation",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L438-L472
|
11,235
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
resend_dcv
|
def resend_dcv(gandi, resource):
""" Resend the DCV mail.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not update, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
id_ = ids[0]
opers = gandi.oper.list({'cert_id': id_})
if not opers:
gandi.echo('Can not find any operation for this certificate.')
return
oper = opers[0]
if (oper['step'] != 'RUN'
and oper['params']['inner_step'] != 'comodo_oper_updated'):
gandi.echo('This certificate operation is not in the good step to '
'resend the DCV.')
return
if oper['params']['dcv_method'] != 'email':
gandi.echo('This certificate operation is not in email DCV.')
return
gandi.certificate.resend_dcv(oper['id'])
|
python
|
def resend_dcv(gandi, resource):
""" Resend the DCV mail.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not update, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
id_ = ids[0]
opers = gandi.oper.list({'cert_id': id_})
if not opers:
gandi.echo('Can not find any operation for this certificate.')
return
oper = opers[0]
if (oper['step'] != 'RUN'
and oper['params']['inner_step'] != 'comodo_oper_updated'):
gandi.echo('This certificate operation is not in the good step to '
'resend the DCV.')
return
if oper['params']['dcv_method'] != 'email':
gandi.echo('This certificate operation is not in email DCV.')
return
gandi.certificate.resend_dcv(oper['id'])
|
[
"def",
"resend_dcv",
"(",
"gandi",
",",
"resource",
")",
":",
"ids",
"=",
"gandi",
".",
"certificate",
".",
"usable_ids",
"(",
"resource",
")",
"if",
"len",
"(",
"ids",
")",
">",
"1",
":",
"gandi",
".",
"echo",
"(",
"'Will not update, %s is not precise enough.'",
"%",
"resource",
")",
"gandi",
".",
"echo",
"(",
"' * cert : '",
"+",
"'\\n * cert : '",
".",
"join",
"(",
"[",
"str",
"(",
"id_",
")",
"for",
"id_",
"in",
"ids",
"]",
")",
")",
"return",
"id_",
"=",
"ids",
"[",
"0",
"]",
"opers",
"=",
"gandi",
".",
"oper",
".",
"list",
"(",
"{",
"'cert_id'",
":",
"id_",
"}",
")",
"if",
"not",
"opers",
":",
"gandi",
".",
"echo",
"(",
"'Can not find any operation for this certificate.'",
")",
"return",
"oper",
"=",
"opers",
"[",
"0",
"]",
"if",
"(",
"oper",
"[",
"'step'",
"]",
"!=",
"'RUN'",
"and",
"oper",
"[",
"'params'",
"]",
"[",
"'inner_step'",
"]",
"!=",
"'comodo_oper_updated'",
")",
":",
"gandi",
".",
"echo",
"(",
"'This certificate operation is not in the good step to '",
"'resend the DCV.'",
")",
"return",
"if",
"oper",
"[",
"'params'",
"]",
"[",
"'dcv_method'",
"]",
"!=",
"'email'",
":",
"gandi",
".",
"echo",
"(",
"'This certificate operation is not in email DCV.'",
")",
"return",
"gandi",
".",
"certificate",
".",
"resend_dcv",
"(",
"oper",
"[",
"'id'",
"]",
")"
] |
Resend the DCV mail.
Resource can be a CN or an ID
|
[
"Resend",
"the",
"DCV",
"mail",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L478-L509
|
11,236
|
Gandi/gandi.cli
|
gandi/cli/commands/certificate.py
|
delete
|
def delete(gandi, resource, background, force):
""" Revoke the certificate.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not delete, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
if not force:
proceed = click.confirm("Are you sure to delete the certificate %s?" %
resource)
if not proceed:
return
result = gandi.certificate.delete(ids[0], background)
return result
|
python
|
def delete(gandi, resource, background, force):
""" Revoke the certificate.
Resource can be a CN or an ID
"""
ids = gandi.certificate.usable_ids(resource)
if len(ids) > 1:
gandi.echo('Will not delete, %s is not precise enough.' % resource)
gandi.echo(' * cert : ' +
'\n * cert : '.join([str(id_) for id_ in ids]))
return
if not force:
proceed = click.confirm("Are you sure to delete the certificate %s?" %
resource)
if not proceed:
return
result = gandi.certificate.delete(ids[0], background)
return result
|
[
"def",
"delete",
"(",
"gandi",
",",
"resource",
",",
"background",
",",
"force",
")",
":",
"ids",
"=",
"gandi",
".",
"certificate",
".",
"usable_ids",
"(",
"resource",
")",
"if",
"len",
"(",
"ids",
")",
">",
"1",
":",
"gandi",
".",
"echo",
"(",
"'Will not delete, %s is not precise enough.'",
"%",
"resource",
")",
"gandi",
".",
"echo",
"(",
"' * cert : '",
"+",
"'\\n * cert : '",
".",
"join",
"(",
"[",
"str",
"(",
"id_",
")",
"for",
"id_",
"in",
"ids",
"]",
")",
")",
"return",
"if",
"not",
"force",
":",
"proceed",
"=",
"click",
".",
"confirm",
"(",
"\"Are you sure to delete the certificate %s?\"",
"%",
"resource",
")",
"if",
"not",
"proceed",
":",
"return",
"result",
"=",
"gandi",
".",
"certificate",
".",
"delete",
"(",
"ids",
"[",
"0",
"]",
",",
"background",
")",
"return",
"result"
] |
Revoke the certificate.
Resource can be a CN or an ID
|
[
"Revoke",
"the",
"certificate",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certificate.py#L520-L540
|
11,237
|
Gandi/gandi.cli
|
gandi/cli/commands/certstore.py
|
list
|
def list(gandi, id, vhosts, dates, fqdns, limit):
""" List hosted certificates. """
justify = 10
options = {'items_per_page': limit, 'state': 'created'}
output_keys = []
if id:
output_keys.append('id')
output_keys.append('subject')
if dates:
output_keys.extend(['date_created', 'date_expire'])
justify = 12
if fqdns:
output_keys.append('fqdns')
if vhosts:
output_keys.append('vhosts')
result = gandi.hostedcert.list(options)
for num, hcert in enumerate(result):
if num:
gandi.separator_line()
if fqdns or vhosts:
hcert = gandi.hostedcert.info(hcert['id'])
output_hostedcert(gandi, hcert, output_keys, justify)
return result
|
python
|
def list(gandi, id, vhosts, dates, fqdns, limit):
""" List hosted certificates. """
justify = 10
options = {'items_per_page': limit, 'state': 'created'}
output_keys = []
if id:
output_keys.append('id')
output_keys.append('subject')
if dates:
output_keys.extend(['date_created', 'date_expire'])
justify = 12
if fqdns:
output_keys.append('fqdns')
if vhosts:
output_keys.append('vhosts')
result = gandi.hostedcert.list(options)
for num, hcert in enumerate(result):
if num:
gandi.separator_line()
if fqdns or vhosts:
hcert = gandi.hostedcert.info(hcert['id'])
output_hostedcert(gandi, hcert, output_keys, justify)
return result
|
[
"def",
"list",
"(",
"gandi",
",",
"id",
",",
"vhosts",
",",
"dates",
",",
"fqdns",
",",
"limit",
")",
":",
"justify",
"=",
"10",
"options",
"=",
"{",
"'items_per_page'",
":",
"limit",
",",
"'state'",
":",
"'created'",
"}",
"output_keys",
"=",
"[",
"]",
"if",
"id",
":",
"output_keys",
".",
"append",
"(",
"'id'",
")",
"output_keys",
".",
"append",
"(",
"'subject'",
")",
"if",
"dates",
":",
"output_keys",
".",
"extend",
"(",
"[",
"'date_created'",
",",
"'date_expire'",
"]",
")",
"justify",
"=",
"12",
"if",
"fqdns",
":",
"output_keys",
".",
"append",
"(",
"'fqdns'",
")",
"if",
"vhosts",
":",
"output_keys",
".",
"append",
"(",
"'vhosts'",
")",
"result",
"=",
"gandi",
".",
"hostedcert",
".",
"list",
"(",
"options",
")",
"for",
"num",
",",
"hcert",
"in",
"enumerate",
"(",
"result",
")",
":",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"if",
"fqdns",
"or",
"vhosts",
":",
"hcert",
"=",
"gandi",
".",
"hostedcert",
".",
"info",
"(",
"hcert",
"[",
"'id'",
"]",
")",
"output_hostedcert",
"(",
"gandi",
",",
"hcert",
",",
"output_keys",
",",
"justify",
")",
"return",
"result"
] |
List hosted certificates.
|
[
"List",
"hosted",
"certificates",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certstore.py#L33-L66
|
11,238
|
Gandi/gandi.cli
|
gandi/cli/commands/certstore.py
|
info
|
def info(gandi, resource):
""" Display information about a hosted certificate.
Resource can be a FQDN or an ID
"""
output_keys = ['id', 'subject', 'date_created', 'date_expire',
'fqdns', 'vhosts']
result = gandi.hostedcert.infos(resource)
for num, hcert in enumerate(result):
if num:
gandi.separator_line()
output_hostedcert(gandi, hcert, output_keys)
return result
|
python
|
def info(gandi, resource):
""" Display information about a hosted certificate.
Resource can be a FQDN or an ID
"""
output_keys = ['id', 'subject', 'date_created', 'date_expire',
'fqdns', 'vhosts']
result = gandi.hostedcert.infos(resource)
for num, hcert in enumerate(result):
if num:
gandi.separator_line()
output_hostedcert(gandi, hcert, output_keys)
return result
|
[
"def",
"info",
"(",
"gandi",
",",
"resource",
")",
":",
"output_keys",
"=",
"[",
"'id'",
",",
"'subject'",
",",
"'date_created'",
",",
"'date_expire'",
",",
"'fqdns'",
",",
"'vhosts'",
"]",
"result",
"=",
"gandi",
".",
"hostedcert",
".",
"infos",
"(",
"resource",
")",
"for",
"num",
",",
"hcert",
"in",
"enumerate",
"(",
"result",
")",
":",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"output_hostedcert",
"(",
"gandi",
",",
"hcert",
",",
"output_keys",
")",
"return",
"result"
] |
Display information about a hosted certificate.
Resource can be a FQDN or an ID
|
[
"Display",
"information",
"about",
"a",
"hosted",
"certificate",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certstore.py#L72-L86
|
11,239
|
Gandi/gandi.cli
|
gandi/cli/commands/certstore.py
|
create
|
def create(gandi, private_key, certificate, certificate_id):
""" Create a new hosted certificate. """
if not certificate and not certificate_id:
gandi.echo('One of --certificate or --certificate-id is needed.')
return
if certificate and certificate_id:
gandi.echo('Only one of --certificate or --certificate-id is needed.')
if os.path.isfile(private_key):
with open(private_key) as fhandle:
private_key = fhandle.read()
if certificate:
if os.path.isfile(certificate):
with open(certificate) as fhandle:
certificate = fhandle.read()
else:
cert = gandi.certificate.info(certificate_id)
certificate = gandi.certificate.pretty_format_cert(cert)
result = gandi.hostedcert.create(private_key, certificate)
output_keys = ['id', 'subject', 'date_created', 'date_expire',
'fqdns', 'vhosts']
output_hostedcert(gandi, result, output_keys)
return result
|
python
|
def create(gandi, private_key, certificate, certificate_id):
""" Create a new hosted certificate. """
if not certificate and not certificate_id:
gandi.echo('One of --certificate or --certificate-id is needed.')
return
if certificate and certificate_id:
gandi.echo('Only one of --certificate or --certificate-id is needed.')
if os.path.isfile(private_key):
with open(private_key) as fhandle:
private_key = fhandle.read()
if certificate:
if os.path.isfile(certificate):
with open(certificate) as fhandle:
certificate = fhandle.read()
else:
cert = gandi.certificate.info(certificate_id)
certificate = gandi.certificate.pretty_format_cert(cert)
result = gandi.hostedcert.create(private_key, certificate)
output_keys = ['id', 'subject', 'date_created', 'date_expire',
'fqdns', 'vhosts']
output_hostedcert(gandi, result, output_keys)
return result
|
[
"def",
"create",
"(",
"gandi",
",",
"private_key",
",",
"certificate",
",",
"certificate_id",
")",
":",
"if",
"not",
"certificate",
"and",
"not",
"certificate_id",
":",
"gandi",
".",
"echo",
"(",
"'One of --certificate or --certificate-id is needed.'",
")",
"return",
"if",
"certificate",
"and",
"certificate_id",
":",
"gandi",
".",
"echo",
"(",
"'Only one of --certificate or --certificate-id is needed.'",
")",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"private_key",
")",
":",
"with",
"open",
"(",
"private_key",
")",
"as",
"fhandle",
":",
"private_key",
"=",
"fhandle",
".",
"read",
"(",
")",
"if",
"certificate",
":",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"certificate",
")",
":",
"with",
"open",
"(",
"certificate",
")",
"as",
"fhandle",
":",
"certificate",
"=",
"fhandle",
".",
"read",
"(",
")",
"else",
":",
"cert",
"=",
"gandi",
".",
"certificate",
".",
"info",
"(",
"certificate_id",
")",
"certificate",
"=",
"gandi",
".",
"certificate",
".",
"pretty_format_cert",
"(",
"cert",
")",
"result",
"=",
"gandi",
".",
"hostedcert",
".",
"create",
"(",
"private_key",
",",
"certificate",
")",
"output_keys",
"=",
"[",
"'id'",
",",
"'subject'",
",",
"'date_created'",
",",
"'date_expire'",
",",
"'fqdns'",
",",
"'vhosts'",
"]",
"output_hostedcert",
"(",
"gandi",
",",
"result",
",",
"output_keys",
")",
"return",
"result"
] |
Create a new hosted certificate.
|
[
"Create",
"a",
"new",
"hosted",
"certificate",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certstore.py#L97-L124
|
11,240
|
Gandi/gandi.cli
|
gandi/cli/commands/certstore.py
|
delete
|
def delete(gandi, resource, force):
""" Delete a hosted certificate.
Resource can be a FQDN or an ID
"""
infos = gandi.hostedcert.infos(resource)
if not infos:
return
if not force:
proceed = click.confirm('Are you sure to delete the following hosted '
'certificates ?\n' +
'\n'.join(['%s: %s' % (res['id'],
res['subject'])
for res in infos]) + '\n')
if not proceed:
return
for res in infos:
gandi.hostedcert.delete(res['id'])
|
python
|
def delete(gandi, resource, force):
""" Delete a hosted certificate.
Resource can be a FQDN or an ID
"""
infos = gandi.hostedcert.infos(resource)
if not infos:
return
if not force:
proceed = click.confirm('Are you sure to delete the following hosted '
'certificates ?\n' +
'\n'.join(['%s: %s' % (res['id'],
res['subject'])
for res in infos]) + '\n')
if not proceed:
return
for res in infos:
gandi.hostedcert.delete(res['id'])
|
[
"def",
"delete",
"(",
"gandi",
",",
"resource",
",",
"force",
")",
":",
"infos",
"=",
"gandi",
".",
"hostedcert",
".",
"infos",
"(",
"resource",
")",
"if",
"not",
"infos",
":",
"return",
"if",
"not",
"force",
":",
"proceed",
"=",
"click",
".",
"confirm",
"(",
"'Are you sure to delete the following hosted '",
"'certificates ?\\n'",
"+",
"'\\n'",
".",
"join",
"(",
"[",
"'%s: %s'",
"%",
"(",
"res",
"[",
"'id'",
"]",
",",
"res",
"[",
"'subject'",
"]",
")",
"for",
"res",
"in",
"infos",
"]",
")",
"+",
"'\\n'",
")",
"if",
"not",
"proceed",
":",
"return",
"for",
"res",
"in",
"infos",
":",
"gandi",
".",
"hostedcert",
".",
"delete",
"(",
"res",
"[",
"'id'",
"]",
")"
] |
Delete a hosted certificate.
Resource can be a FQDN or an ID
|
[
"Delete",
"a",
"hosted",
"certificate",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/certstore.py#L133-L152
|
11,241
|
aykut/django-bulk-update
|
django_bulk_update/helper.py
|
flatten
|
def flatten(l, types=(list, float)):
"""
Flat nested list of lists into a single list.
"""
l = [item if isinstance(item, types) else [item] for item in l]
return [item for sublist in l for item in sublist]
|
python
|
def flatten(l, types=(list, float)):
"""
Flat nested list of lists into a single list.
"""
l = [item if isinstance(item, types) else [item] for item in l]
return [item for sublist in l for item in sublist]
|
[
"def",
"flatten",
"(",
"l",
",",
"types",
"=",
"(",
"list",
",",
"float",
")",
")",
":",
"l",
"=",
"[",
"item",
"if",
"isinstance",
"(",
"item",
",",
"types",
")",
"else",
"[",
"item",
"]",
"for",
"item",
"in",
"l",
"]",
"return",
"[",
"item",
"for",
"sublist",
"in",
"l",
"for",
"item",
"in",
"sublist",
"]"
] |
Flat nested list of lists into a single list.
|
[
"Flat",
"nested",
"list",
"of",
"lists",
"into",
"a",
"single",
"list",
"."
] |
399e64d820133a79f910682c1cf247938c5c4784
|
https://github.com/aykut/django-bulk-update/blob/399e64d820133a79f910682c1cf247938c5c4784/django_bulk_update/helper.py#L41-L46
|
11,242
|
aitjcize/cppman
|
cppman/util.py
|
get_width
|
def get_width():
"""Get terminal width"""
# Get terminal size
ws = struct.pack("HHHH", 0, 0, 0, 0)
ws = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, ws)
lines, columns, x, y = struct.unpack("HHHH", ws)
width = min(columns * 39 // 40, columns - 2)
return width
|
python
|
def get_width():
"""Get terminal width"""
# Get terminal size
ws = struct.pack("HHHH", 0, 0, 0, 0)
ws = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, ws)
lines, columns, x, y = struct.unpack("HHHH", ws)
width = min(columns * 39 // 40, columns - 2)
return width
|
[
"def",
"get_width",
"(",
")",
":",
"# Get terminal size",
"ws",
"=",
"struct",
".",
"pack",
"(",
"\"HHHH\"",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
")",
"ws",
"=",
"fcntl",
".",
"ioctl",
"(",
"sys",
".",
"stdout",
".",
"fileno",
"(",
")",
",",
"termios",
".",
"TIOCGWINSZ",
",",
"ws",
")",
"lines",
",",
"columns",
",",
"x",
",",
"y",
"=",
"struct",
".",
"unpack",
"(",
"\"HHHH\"",
",",
"ws",
")",
"width",
"=",
"min",
"(",
"columns",
"*",
"39",
"//",
"40",
",",
"columns",
"-",
"2",
")",
"return",
"width"
] |
Get terminal width
|
[
"Get",
"terminal",
"width"
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/util.py#L83-L90
|
11,243
|
aitjcize/cppman
|
cppman/util.py
|
groff2man
|
def groff2man(data):
"""Read groff-formatted text and output man pages."""
width = get_width()
cmd = 'groff -t -Tascii -m man -rLL=%dn -rLT=%dn' % (width, width)
handle = subprocess.Popen(
cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
man_text, stderr = handle.communicate(data)
return man_text
|
python
|
def groff2man(data):
"""Read groff-formatted text and output man pages."""
width = get_width()
cmd = 'groff -t -Tascii -m man -rLL=%dn -rLT=%dn' % (width, width)
handle = subprocess.Popen(
cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
man_text, stderr = handle.communicate(data)
return man_text
|
[
"def",
"groff2man",
"(",
"data",
")",
":",
"width",
"=",
"get_width",
"(",
")",
"cmd",
"=",
"'groff -t -Tascii -m man -rLL=%dn -rLT=%dn'",
"%",
"(",
"width",
",",
"width",
")",
"handle",
"=",
"subprocess",
".",
"Popen",
"(",
"cmd",
",",
"shell",
"=",
"True",
",",
"stdin",
"=",
"subprocess",
".",
"PIPE",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
"man_text",
",",
"stderr",
"=",
"handle",
".",
"communicate",
"(",
"data",
")",
"return",
"man_text"
] |
Read groff-formatted text and output man pages.
|
[
"Read",
"groff",
"-",
"formatted",
"text",
"and",
"output",
"man",
"pages",
"."
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/util.py#L93-L102
|
11,244
|
aitjcize/cppman
|
cppman/main.py
|
Cppman.extract_name
|
def extract_name(self, data):
"""Extract man page name from web page."""
name = re.search('<h1[^>]*>(.+?)</h1>', data).group(1)
name = re.sub(r'<([^>]+)>', r'', name)
name = re.sub(r'>', r'>', name)
name = re.sub(r'<', r'<', name)
return name
|
python
|
def extract_name(self, data):
"""Extract man page name from web page."""
name = re.search('<h1[^>]*>(.+?)</h1>', data).group(1)
name = re.sub(r'<([^>]+)>', r'', name)
name = re.sub(r'>', r'>', name)
name = re.sub(r'<', r'<', name)
return name
|
[
"def",
"extract_name",
"(",
"self",
",",
"data",
")",
":",
"name",
"=",
"re",
".",
"search",
"(",
"'<h1[^>]*>(.+?)</h1>'",
",",
"data",
")",
".",
"group",
"(",
"1",
")",
"name",
"=",
"re",
".",
"sub",
"(",
"r'<([^>]+)>'",
",",
"r''",
",",
"name",
")",
"name",
"=",
"re",
".",
"sub",
"(",
"r'>'",
",",
"r'>'",
",",
"name",
")",
"name",
"=",
"re",
".",
"sub",
"(",
"r'<'",
",",
"r'<'",
",",
"name",
")",
"return",
"name"
] |
Extract man page name from web page.
|
[
"Extract",
"man",
"page",
"name",
"from",
"web",
"page",
"."
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/main.py#L56-L62
|
11,245
|
aitjcize/cppman
|
cppman/main.py
|
Cppman.cache_all
|
def cache_all(self):
"""Cache all available man pages"""
respond = input(
'By default, cppman fetches pages on-the-fly if corresponding '
'page is not found in the cache. The "cache-all" option is only '
'useful if you want to view man pages offline. '
'Caching all contents will take several minutes, '
'do you want to continue [y/N]? ')
if not (respond and 'yes'.startswith(respond.lower())):
raise KeyboardInterrupt
try:
os.makedirs(environ.cache_dir)
except:
pass
self.success_count = 0
self.failure_count = 0
if not os.path.exists(environ.index_db):
raise RuntimeError("can't find index.db")
conn = sqlite3.connect(environ.index_db)
cursor = conn.cursor()
source = environ.config.source
print('Caching manpages from %s ...' % source)
data = cursor.execute('SELECT * FROM "%s"' % source).fetchall()
for name, url, _ in data:
print('Caching %s ...' % name)
retries = 3
while retries > 0:
try:
self.cache_man_page(source, url, name)
except Exception:
print('Retrying ...')
retries -= 1
else:
self.success_count += 1
break
else:
print('Error caching %s ...' % name)
self.failure_count += 1
conn.close()
print('\n%d manual pages cached successfully.' % self.success_count)
print('%d manual pages failed to cache.' % self.failure_count)
self.update_mandb(False)
|
python
|
def cache_all(self):
"""Cache all available man pages"""
respond = input(
'By default, cppman fetches pages on-the-fly if corresponding '
'page is not found in the cache. The "cache-all" option is only '
'useful if you want to view man pages offline. '
'Caching all contents will take several minutes, '
'do you want to continue [y/N]? ')
if not (respond and 'yes'.startswith(respond.lower())):
raise KeyboardInterrupt
try:
os.makedirs(environ.cache_dir)
except:
pass
self.success_count = 0
self.failure_count = 0
if not os.path.exists(environ.index_db):
raise RuntimeError("can't find index.db")
conn = sqlite3.connect(environ.index_db)
cursor = conn.cursor()
source = environ.config.source
print('Caching manpages from %s ...' % source)
data = cursor.execute('SELECT * FROM "%s"' % source).fetchall()
for name, url, _ in data:
print('Caching %s ...' % name)
retries = 3
while retries > 0:
try:
self.cache_man_page(source, url, name)
except Exception:
print('Retrying ...')
retries -= 1
else:
self.success_count += 1
break
else:
print('Error caching %s ...' % name)
self.failure_count += 1
conn.close()
print('\n%d manual pages cached successfully.' % self.success_count)
print('%d manual pages failed to cache.' % self.failure_count)
self.update_mandb(False)
|
[
"def",
"cache_all",
"(",
"self",
")",
":",
"respond",
"=",
"input",
"(",
"'By default, cppman fetches pages on-the-fly if corresponding '",
"'page is not found in the cache. The \"cache-all\" option is only '",
"'useful if you want to view man pages offline. '",
"'Caching all contents will take several minutes, '",
"'do you want to continue [y/N]? '",
")",
"if",
"not",
"(",
"respond",
"and",
"'yes'",
".",
"startswith",
"(",
"respond",
".",
"lower",
"(",
")",
")",
")",
":",
"raise",
"KeyboardInterrupt",
"try",
":",
"os",
".",
"makedirs",
"(",
"environ",
".",
"cache_dir",
")",
"except",
":",
"pass",
"self",
".",
"success_count",
"=",
"0",
"self",
".",
"failure_count",
"=",
"0",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"environ",
".",
"index_db",
")",
":",
"raise",
"RuntimeError",
"(",
"\"can't find index.db\"",
")",
"conn",
"=",
"sqlite3",
".",
"connect",
"(",
"environ",
".",
"index_db",
")",
"cursor",
"=",
"conn",
".",
"cursor",
"(",
")",
"source",
"=",
"environ",
".",
"config",
".",
"source",
"print",
"(",
"'Caching manpages from %s ...'",
"%",
"source",
")",
"data",
"=",
"cursor",
".",
"execute",
"(",
"'SELECT * FROM \"%s\"'",
"%",
"source",
")",
".",
"fetchall",
"(",
")",
"for",
"name",
",",
"url",
",",
"_",
"in",
"data",
":",
"print",
"(",
"'Caching %s ...'",
"%",
"name",
")",
"retries",
"=",
"3",
"while",
"retries",
">",
"0",
":",
"try",
":",
"self",
".",
"cache_man_page",
"(",
"source",
",",
"url",
",",
"name",
")",
"except",
"Exception",
":",
"print",
"(",
"'Retrying ...'",
")",
"retries",
"-=",
"1",
"else",
":",
"self",
".",
"success_count",
"+=",
"1",
"break",
"else",
":",
"print",
"(",
"'Error caching %s ...'",
"%",
"name",
")",
"self",
".",
"failure_count",
"+=",
"1",
"conn",
".",
"close",
"(",
")",
"print",
"(",
"'\\n%d manual pages cached successfully.'",
"%",
"self",
".",
"success_count",
")",
"print",
"(",
"'%d manual pages failed to cache.'",
"%",
"self",
".",
"failure_count",
")",
"self",
".",
"update_mandb",
"(",
"False",
")"
] |
Cache all available man pages
|
[
"Cache",
"all",
"available",
"man",
"pages"
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/main.py#L204-L254
|
11,246
|
aitjcize/cppman
|
cppman/main.py
|
Cppman.cache_man_page
|
def cache_man_page(self, source, url, name):
"""callback to cache new man page"""
# Skip if already exists, override if forced flag is true
outname = self.get_page_path(source, name)
if os.path.exists(outname) and not self.forced:
return
try:
os.makedirs(os.path.join(environ.cache_dir, source))
except OSError:
pass
# There are often some errors in the HTML, for example: missing closing
# tag. We use fixupHTML to fix this.
data = util.fixupHTML(urllib.request.urlopen(url).read())
formatter = importlib.import_module('cppman.formatter.%s' % source[:-4])
groff_text = formatter.html2groff(data, name)
with gzip.open(outname, 'w') as f:
f.write(groff_text.encode('utf-8'))
|
python
|
def cache_man_page(self, source, url, name):
"""callback to cache new man page"""
# Skip if already exists, override if forced flag is true
outname = self.get_page_path(source, name)
if os.path.exists(outname) and not self.forced:
return
try:
os.makedirs(os.path.join(environ.cache_dir, source))
except OSError:
pass
# There are often some errors in the HTML, for example: missing closing
# tag. We use fixupHTML to fix this.
data = util.fixupHTML(urllib.request.urlopen(url).read())
formatter = importlib.import_module('cppman.formatter.%s' % source[:-4])
groff_text = formatter.html2groff(data, name)
with gzip.open(outname, 'w') as f:
f.write(groff_text.encode('utf-8'))
|
[
"def",
"cache_man_page",
"(",
"self",
",",
"source",
",",
"url",
",",
"name",
")",
":",
"# Skip if already exists, override if forced flag is true",
"outname",
"=",
"self",
".",
"get_page_path",
"(",
"source",
",",
"name",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"outname",
")",
"and",
"not",
"self",
".",
"forced",
":",
"return",
"try",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"join",
"(",
"environ",
".",
"cache_dir",
",",
"source",
")",
")",
"except",
"OSError",
":",
"pass",
"# There are often some errors in the HTML, for example: missing closing",
"# tag. We use fixupHTML to fix this.",
"data",
"=",
"util",
".",
"fixupHTML",
"(",
"urllib",
".",
"request",
".",
"urlopen",
"(",
"url",
")",
".",
"read",
"(",
")",
")",
"formatter",
"=",
"importlib",
".",
"import_module",
"(",
"'cppman.formatter.%s'",
"%",
"source",
"[",
":",
"-",
"4",
"]",
")",
"groff_text",
"=",
"formatter",
".",
"html2groff",
"(",
"data",
",",
"name",
")",
"with",
"gzip",
".",
"open",
"(",
"outname",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"groff_text",
".",
"encode",
"(",
"'utf-8'",
")",
")"
] |
callback to cache new man page
|
[
"callback",
"to",
"cache",
"new",
"man",
"page"
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/main.py#L256-L276
|
11,247
|
aitjcize/cppman
|
cppman/main.py
|
Cppman.man
|
def man(self, pattern):
"""Call viewer.sh to view man page"""
try:
avail = os.listdir(os.path.join(environ.cache_dir, environ.source))
except OSError:
avail = []
if not os.path.exists(environ.index_db):
raise RuntimeError("can't find index.db")
conn = sqlite3.connect(environ.index_db)
cursor = conn.cursor()
# Try direct match
try:
page_name, url = cursor.execute(
'SELECT name,url FROM "%s" '
'WHERE name="%s" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchone()
except TypeError:
# Try standard library
try:
page_name, url = cursor.execute(
'SELECT name,url FROM "%s" '
'WHERE name="std::%s" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchone()
except TypeError:
try:
page_name, url = cursor.execute(
'SELECT name,url FROM "%s" '
'WHERE name LIKE "%%%s%%" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchone()
except TypeError:
raise RuntimeError('No manual entry for ' + pattern)
finally:
conn.close()
page_filename = self.get_normalized_page_name(page_name)
if self.forced or page_filename + '.3.gz' not in avail:
self.cache_man_page(environ.source, url, page_name)
pager_type = environ.pager if sys.stdout.isatty() else 'pipe'
# Call viewer
columns = (util.get_width() if self.force_columns == -1 else
self.force_columns)
pid = os.fork()
if pid == 0:
os.execl('/bin/sh', '/bin/sh', environ.pager_script, pager_type,
self.get_page_path(environ.source, page_name),
str(columns), environ.pager_config, page_name)
return pid
|
python
|
def man(self, pattern):
"""Call viewer.sh to view man page"""
try:
avail = os.listdir(os.path.join(environ.cache_dir, environ.source))
except OSError:
avail = []
if not os.path.exists(environ.index_db):
raise RuntimeError("can't find index.db")
conn = sqlite3.connect(environ.index_db)
cursor = conn.cursor()
# Try direct match
try:
page_name, url = cursor.execute(
'SELECT name,url FROM "%s" '
'WHERE name="%s" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchone()
except TypeError:
# Try standard library
try:
page_name, url = cursor.execute(
'SELECT name,url FROM "%s" '
'WHERE name="std::%s" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchone()
except TypeError:
try:
page_name, url = cursor.execute(
'SELECT name,url FROM "%s" '
'WHERE name LIKE "%%%s%%" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchone()
except TypeError:
raise RuntimeError('No manual entry for ' + pattern)
finally:
conn.close()
page_filename = self.get_normalized_page_name(page_name)
if self.forced or page_filename + '.3.gz' not in avail:
self.cache_man_page(environ.source, url, page_name)
pager_type = environ.pager if sys.stdout.isatty() else 'pipe'
# Call viewer
columns = (util.get_width() if self.force_columns == -1 else
self.force_columns)
pid = os.fork()
if pid == 0:
os.execl('/bin/sh', '/bin/sh', environ.pager_script, pager_type,
self.get_page_path(environ.source, page_name),
str(columns), environ.pager_config, page_name)
return pid
|
[
"def",
"man",
"(",
"self",
",",
"pattern",
")",
":",
"try",
":",
"avail",
"=",
"os",
".",
"listdir",
"(",
"os",
".",
"path",
".",
"join",
"(",
"environ",
".",
"cache_dir",
",",
"environ",
".",
"source",
")",
")",
"except",
"OSError",
":",
"avail",
"=",
"[",
"]",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"environ",
".",
"index_db",
")",
":",
"raise",
"RuntimeError",
"(",
"\"can't find index.db\"",
")",
"conn",
"=",
"sqlite3",
".",
"connect",
"(",
"environ",
".",
"index_db",
")",
"cursor",
"=",
"conn",
".",
"cursor",
"(",
")",
"# Try direct match",
"try",
":",
"page_name",
",",
"url",
"=",
"cursor",
".",
"execute",
"(",
"'SELECT name,url FROM \"%s\" '",
"'WHERE name=\"%s\" ORDER BY LENGTH(name)'",
"%",
"(",
"environ",
".",
"source",
",",
"pattern",
")",
")",
".",
"fetchone",
"(",
")",
"except",
"TypeError",
":",
"# Try standard library",
"try",
":",
"page_name",
",",
"url",
"=",
"cursor",
".",
"execute",
"(",
"'SELECT name,url FROM \"%s\" '",
"'WHERE name=\"std::%s\" ORDER BY LENGTH(name)'",
"%",
"(",
"environ",
".",
"source",
",",
"pattern",
")",
")",
".",
"fetchone",
"(",
")",
"except",
"TypeError",
":",
"try",
":",
"page_name",
",",
"url",
"=",
"cursor",
".",
"execute",
"(",
"'SELECT name,url FROM \"%s\" '",
"'WHERE name LIKE \"%%%s%%\" ORDER BY LENGTH(name)'",
"%",
"(",
"environ",
".",
"source",
",",
"pattern",
")",
")",
".",
"fetchone",
"(",
")",
"except",
"TypeError",
":",
"raise",
"RuntimeError",
"(",
"'No manual entry for '",
"+",
"pattern",
")",
"finally",
":",
"conn",
".",
"close",
"(",
")",
"page_filename",
"=",
"self",
".",
"get_normalized_page_name",
"(",
"page_name",
")",
"if",
"self",
".",
"forced",
"or",
"page_filename",
"+",
"'.3.gz'",
"not",
"in",
"avail",
":",
"self",
".",
"cache_man_page",
"(",
"environ",
".",
"source",
",",
"url",
",",
"page_name",
")",
"pager_type",
"=",
"environ",
".",
"pager",
"if",
"sys",
".",
"stdout",
".",
"isatty",
"(",
")",
"else",
"'pipe'",
"# Call viewer",
"columns",
"=",
"(",
"util",
".",
"get_width",
"(",
")",
"if",
"self",
".",
"force_columns",
"==",
"-",
"1",
"else",
"self",
".",
"force_columns",
")",
"pid",
"=",
"os",
".",
"fork",
"(",
")",
"if",
"pid",
"==",
"0",
":",
"os",
".",
"execl",
"(",
"'/bin/sh'",
",",
"'/bin/sh'",
",",
"environ",
".",
"pager_script",
",",
"pager_type",
",",
"self",
".",
"get_page_path",
"(",
"environ",
".",
"source",
",",
"page_name",
")",
",",
"str",
"(",
"columns",
")",
",",
"environ",
".",
"pager_config",
",",
"page_name",
")",
"return",
"pid"
] |
Call viewer.sh to view man page
|
[
"Call",
"viewer",
".",
"sh",
"to",
"view",
"man",
"page"
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/main.py#L282-L333
|
11,248
|
aitjcize/cppman
|
cppman/main.py
|
Cppman.find
|
def find(self, pattern):
"""Find pages in database."""
if not os.path.exists(environ.index_db):
raise RuntimeError("can't find index.db")
conn = sqlite3.connect(environ.index_db)
cursor = conn.cursor()
selected = cursor.execute(
'SELECT * FROM "%s" WHERE name '
'LIKE "%%%s%%" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchall()
pat = re.compile('(%s)' % re.escape(pattern), re.I)
if selected:
for name, url, std in selected:
if os.isatty(sys.stdout.fileno()):
print(pat.sub(r'\033[1;31m\1\033[0m', name) +
(' \033[1;33m[%s]\033[0m' % std if std else ''))
else:
print(name + (' [%s]' % std if std else ''))
else:
raise RuntimeError('%s: nothing appropriate.' % pattern)
|
python
|
def find(self, pattern):
"""Find pages in database."""
if not os.path.exists(environ.index_db):
raise RuntimeError("can't find index.db")
conn = sqlite3.connect(environ.index_db)
cursor = conn.cursor()
selected = cursor.execute(
'SELECT * FROM "%s" WHERE name '
'LIKE "%%%s%%" ORDER BY LENGTH(name)'
% (environ.source, pattern)).fetchall()
pat = re.compile('(%s)' % re.escape(pattern), re.I)
if selected:
for name, url, std in selected:
if os.isatty(sys.stdout.fileno()):
print(pat.sub(r'\033[1;31m\1\033[0m', name) +
(' \033[1;33m[%s]\033[0m' % std if std else ''))
else:
print(name + (' [%s]' % std if std else ''))
else:
raise RuntimeError('%s: nothing appropriate.' % pattern)
|
[
"def",
"find",
"(",
"self",
",",
"pattern",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"environ",
".",
"index_db",
")",
":",
"raise",
"RuntimeError",
"(",
"\"can't find index.db\"",
")",
"conn",
"=",
"sqlite3",
".",
"connect",
"(",
"environ",
".",
"index_db",
")",
"cursor",
"=",
"conn",
".",
"cursor",
"(",
")",
"selected",
"=",
"cursor",
".",
"execute",
"(",
"'SELECT * FROM \"%s\" WHERE name '",
"'LIKE \"%%%s%%\" ORDER BY LENGTH(name)'",
"%",
"(",
"environ",
".",
"source",
",",
"pattern",
")",
")",
".",
"fetchall",
"(",
")",
"pat",
"=",
"re",
".",
"compile",
"(",
"'(%s)'",
"%",
"re",
".",
"escape",
"(",
"pattern",
")",
",",
"re",
".",
"I",
")",
"if",
"selected",
":",
"for",
"name",
",",
"url",
",",
"std",
"in",
"selected",
":",
"if",
"os",
".",
"isatty",
"(",
"sys",
".",
"stdout",
".",
"fileno",
"(",
")",
")",
":",
"print",
"(",
"pat",
".",
"sub",
"(",
"r'\\033[1;31m\\1\\033[0m'",
",",
"name",
")",
"+",
"(",
"' \\033[1;33m[%s]\\033[0m'",
"%",
"std",
"if",
"std",
"else",
"''",
")",
")",
"else",
":",
"print",
"(",
"name",
"+",
"(",
"' [%s]'",
"%",
"std",
"if",
"std",
"else",
"''",
")",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"'%s: nothing appropriate.'",
"%",
"pattern",
")"
] |
Find pages in database.
|
[
"Find",
"pages",
"in",
"database",
"."
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/main.py#L335-L358
|
11,249
|
aitjcize/cppman
|
cppman/main.py
|
Cppman.update_mandb
|
def update_mandb(self, quiet=True):
"""Update mandb."""
if not environ.config.UpdateManPath:
return
print('\nrunning mandb...')
cmd = 'mandb %s' % (' -q' if quiet else '')
subprocess.Popen(cmd, shell=True).wait()
|
python
|
def update_mandb(self, quiet=True):
"""Update mandb."""
if not environ.config.UpdateManPath:
return
print('\nrunning mandb...')
cmd = 'mandb %s' % (' -q' if quiet else '')
subprocess.Popen(cmd, shell=True).wait()
|
[
"def",
"update_mandb",
"(",
"self",
",",
"quiet",
"=",
"True",
")",
":",
"if",
"not",
"environ",
".",
"config",
".",
"UpdateManPath",
":",
"return",
"print",
"(",
"'\\nrunning mandb...'",
")",
"cmd",
"=",
"'mandb %s'",
"%",
"(",
"' -q'",
"if",
"quiet",
"else",
"''",
")",
"subprocess",
".",
"Popen",
"(",
"cmd",
",",
"shell",
"=",
"True",
")",
".",
"wait",
"(",
")"
] |
Update mandb.
|
[
"Update",
"mandb",
"."
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/main.py#L360-L366
|
11,250
|
aitjcize/cppman
|
cppman/config.py
|
Config.set_default
|
def set_default(self):
"""Set config to default."""
try:
os.makedirs(os.path.dirname(self._configfile))
except:
pass
self._config = configparser.RawConfigParser()
self._config.add_section('Settings')
for key, val in self.DEFAULTS.items():
self._config.set('Settings', key, val)
with open(self._configfile, 'w') as f:
self._config.write(f)
|
python
|
def set_default(self):
"""Set config to default."""
try:
os.makedirs(os.path.dirname(self._configfile))
except:
pass
self._config = configparser.RawConfigParser()
self._config.add_section('Settings')
for key, val in self.DEFAULTS.items():
self._config.set('Settings', key, val)
with open(self._configfile, 'w') as f:
self._config.write(f)
|
[
"def",
"set_default",
"(",
"self",
")",
":",
"try",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"self",
".",
"_configfile",
")",
")",
"except",
":",
"pass",
"self",
".",
"_config",
"=",
"configparser",
".",
"RawConfigParser",
"(",
")",
"self",
".",
"_config",
".",
"add_section",
"(",
"'Settings'",
")",
"for",
"key",
",",
"val",
"in",
"self",
".",
"DEFAULTS",
".",
"items",
"(",
")",
":",
"self",
".",
"_config",
".",
"set",
"(",
"'Settings'",
",",
"key",
",",
"val",
")",
"with",
"open",
"(",
"self",
".",
"_configfile",
",",
"'w'",
")",
"as",
"f",
":",
"self",
".",
"_config",
".",
"write",
"(",
"f",
")"
] |
Set config to default.
|
[
"Set",
"config",
"to",
"default",
"."
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/config.py#L64-L78
|
11,251
|
aitjcize/cppman
|
cppman/config.py
|
Config.save
|
def save(self):
"""Store config back to file."""
try:
os.makedirs(os.path.dirname(self._configfile))
except:
pass
with open(self._configfile, 'w') as f:
self._config.write(f)
|
python
|
def save(self):
"""Store config back to file."""
try:
os.makedirs(os.path.dirname(self._configfile))
except:
pass
with open(self._configfile, 'w') as f:
self._config.write(f)
|
[
"def",
"save",
"(",
"self",
")",
":",
"try",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"self",
".",
"_configfile",
")",
")",
"except",
":",
"pass",
"with",
"open",
"(",
"self",
".",
"_configfile",
",",
"'w'",
")",
"as",
"f",
":",
"self",
".",
"_config",
".",
"write",
"(",
"f",
")"
] |
Store config back to file.
|
[
"Store",
"config",
"back",
"to",
"file",
"."
] |
7b48e81b2cd3baa912d73dfe977ecbaff945a93c
|
https://github.com/aitjcize/cppman/blob/7b48e81b2cd3baa912d73dfe977ecbaff945a93c/cppman/config.py#L80-L88
|
11,252
|
fbcotter/py3nvml
|
py3nvml/utils.py
|
get_free_gpus
|
def get_free_gpus(max_procs=0):
"""
Checks the number of processes running on your GPUs.
Parameters
----------
max_procs : int
Maximum number of procs allowed to run on a gpu for it to be considered
'available'
Returns
-------
availabilities : list(bool)
List of length N for an N-gpu system. The nth value will be true, if the
nth gpu had at most max_procs processes running on it. Set to 0 to look
for gpus with no procs on it.
Note
----
If function can't query the driver will return an empty list rather than raise an
Exception.
"""
# Try connect with NVIDIA drivers
logger = logging.getLogger(__name__)
try:
py3nvml.nvmlInit()
except:
str_ = """Couldn't connect to nvml drivers. Check they are installed correctly."""
warnings.warn(str_, RuntimeWarning)
logger.warn(str_)
return []
num_gpus = py3nvml.nvmlDeviceGetCount()
gpu_free = [False]*num_gpus
for i in range(num_gpus):
try:
h = py3nvml.nvmlDeviceGetHandleByIndex(i)
except:
continue
procs = try_get_info(py3nvml.nvmlDeviceGetComputeRunningProcesses, h,
['something'])
if len(procs) <= max_procs:
gpu_free[i] = True
py3nvml.nvmlShutdown()
return gpu_free
|
python
|
def get_free_gpus(max_procs=0):
"""
Checks the number of processes running on your GPUs.
Parameters
----------
max_procs : int
Maximum number of procs allowed to run on a gpu for it to be considered
'available'
Returns
-------
availabilities : list(bool)
List of length N for an N-gpu system. The nth value will be true, if the
nth gpu had at most max_procs processes running on it. Set to 0 to look
for gpus with no procs on it.
Note
----
If function can't query the driver will return an empty list rather than raise an
Exception.
"""
# Try connect with NVIDIA drivers
logger = logging.getLogger(__name__)
try:
py3nvml.nvmlInit()
except:
str_ = """Couldn't connect to nvml drivers. Check they are installed correctly."""
warnings.warn(str_, RuntimeWarning)
logger.warn(str_)
return []
num_gpus = py3nvml.nvmlDeviceGetCount()
gpu_free = [False]*num_gpus
for i in range(num_gpus):
try:
h = py3nvml.nvmlDeviceGetHandleByIndex(i)
except:
continue
procs = try_get_info(py3nvml.nvmlDeviceGetComputeRunningProcesses, h,
['something'])
if len(procs) <= max_procs:
gpu_free[i] = True
py3nvml.nvmlShutdown()
return gpu_free
|
[
"def",
"get_free_gpus",
"(",
"max_procs",
"=",
"0",
")",
":",
"# Try connect with NVIDIA drivers",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"__name__",
")",
"try",
":",
"py3nvml",
".",
"nvmlInit",
"(",
")",
"except",
":",
"str_",
"=",
"\"\"\"Couldn't connect to nvml drivers. Check they are installed correctly.\"\"\"",
"warnings",
".",
"warn",
"(",
"str_",
",",
"RuntimeWarning",
")",
"logger",
".",
"warn",
"(",
"str_",
")",
"return",
"[",
"]",
"num_gpus",
"=",
"py3nvml",
".",
"nvmlDeviceGetCount",
"(",
")",
"gpu_free",
"=",
"[",
"False",
"]",
"*",
"num_gpus",
"for",
"i",
"in",
"range",
"(",
"num_gpus",
")",
":",
"try",
":",
"h",
"=",
"py3nvml",
".",
"nvmlDeviceGetHandleByIndex",
"(",
"i",
")",
"except",
":",
"continue",
"procs",
"=",
"try_get_info",
"(",
"py3nvml",
".",
"nvmlDeviceGetComputeRunningProcesses",
",",
"h",
",",
"[",
"'something'",
"]",
")",
"if",
"len",
"(",
"procs",
")",
"<=",
"max_procs",
":",
"gpu_free",
"[",
"i",
"]",
"=",
"True",
"py3nvml",
".",
"nvmlShutdown",
"(",
")",
"return",
"gpu_free"
] |
Checks the number of processes running on your GPUs.
Parameters
----------
max_procs : int
Maximum number of procs allowed to run on a gpu for it to be considered
'available'
Returns
-------
availabilities : list(bool)
List of length N for an N-gpu system. The nth value will be true, if the
nth gpu had at most max_procs processes running on it. Set to 0 to look
for gpus with no procs on it.
Note
----
If function can't query the driver will return an empty list rather than raise an
Exception.
|
[
"Checks",
"the",
"number",
"of",
"processes",
"running",
"on",
"your",
"GPUs",
"."
] |
47f0f2c0eee56dec4e4beebec26b734e01d357b7
|
https://github.com/fbcotter/py3nvml/blob/47f0f2c0eee56dec4e4beebec26b734e01d357b7/py3nvml/utils.py#L170-L216
|
11,253
|
fbcotter/py3nvml
|
py3nvml/utils.py
|
get_num_procs
|
def get_num_procs():
""" Gets the number of processes running on each gpu
Returns
-------
num_procs : list(int)
Number of processes running on each gpu
Note
----
If function can't query the driver will return an empty list rather than raise an
Exception.
Note
----
If function can't get the info from the gpu will return -1 in that gpu's place
"""
# Try connect with NVIDIA drivers
logger = logging.getLogger(__name__)
try:
py3nvml.nvmlInit()
except:
str_ = """Couldn't connect to nvml drivers. Check they are installed correctly."""
warnings.warn(str_, RuntimeWarning)
logger.warn(str_)
return []
num_gpus = py3nvml.nvmlDeviceGetCount()
gpu_procs = [-1]*num_gpus
for i in range(num_gpus):
try:
h = py3nvml.nvmlDeviceGetHandleByIndex(i)
except:
continue
procs = try_get_info(py3nvml.nvmlDeviceGetComputeRunningProcesses, h,
['something'])
gpu_procs[i] = len(procs)
py3nvml.nvmlShutdown()
return gpu_procs
|
python
|
def get_num_procs():
""" Gets the number of processes running on each gpu
Returns
-------
num_procs : list(int)
Number of processes running on each gpu
Note
----
If function can't query the driver will return an empty list rather than raise an
Exception.
Note
----
If function can't get the info from the gpu will return -1 in that gpu's place
"""
# Try connect with NVIDIA drivers
logger = logging.getLogger(__name__)
try:
py3nvml.nvmlInit()
except:
str_ = """Couldn't connect to nvml drivers. Check they are installed correctly."""
warnings.warn(str_, RuntimeWarning)
logger.warn(str_)
return []
num_gpus = py3nvml.nvmlDeviceGetCount()
gpu_procs = [-1]*num_gpus
for i in range(num_gpus):
try:
h = py3nvml.nvmlDeviceGetHandleByIndex(i)
except:
continue
procs = try_get_info(py3nvml.nvmlDeviceGetComputeRunningProcesses, h,
['something'])
gpu_procs[i] = len(procs)
py3nvml.nvmlShutdown()
return gpu_procs
|
[
"def",
"get_num_procs",
"(",
")",
":",
"# Try connect with NVIDIA drivers",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"__name__",
")",
"try",
":",
"py3nvml",
".",
"nvmlInit",
"(",
")",
"except",
":",
"str_",
"=",
"\"\"\"Couldn't connect to nvml drivers. Check they are installed correctly.\"\"\"",
"warnings",
".",
"warn",
"(",
"str_",
",",
"RuntimeWarning",
")",
"logger",
".",
"warn",
"(",
"str_",
")",
"return",
"[",
"]",
"num_gpus",
"=",
"py3nvml",
".",
"nvmlDeviceGetCount",
"(",
")",
"gpu_procs",
"=",
"[",
"-",
"1",
"]",
"*",
"num_gpus",
"for",
"i",
"in",
"range",
"(",
"num_gpus",
")",
":",
"try",
":",
"h",
"=",
"py3nvml",
".",
"nvmlDeviceGetHandleByIndex",
"(",
"i",
")",
"except",
":",
"continue",
"procs",
"=",
"try_get_info",
"(",
"py3nvml",
".",
"nvmlDeviceGetComputeRunningProcesses",
",",
"h",
",",
"[",
"'something'",
"]",
")",
"gpu_procs",
"[",
"i",
"]",
"=",
"len",
"(",
"procs",
")",
"py3nvml",
".",
"nvmlShutdown",
"(",
")",
"return",
"gpu_procs"
] |
Gets the number of processes running on each gpu
Returns
-------
num_procs : list(int)
Number of processes running on each gpu
Note
----
If function can't query the driver will return an empty list rather than raise an
Exception.
Note
----
If function can't get the info from the gpu will return -1 in that gpu's place
|
[
"Gets",
"the",
"number",
"of",
"processes",
"running",
"on",
"each",
"gpu"
] |
47f0f2c0eee56dec4e4beebec26b734e01d357b7
|
https://github.com/fbcotter/py3nvml/blob/47f0f2c0eee56dec4e4beebec26b734e01d357b7/py3nvml/utils.py#L219-L258
|
11,254
|
fbcotter/py3nvml
|
py3nvml/py3nvml.py
|
_extractNVMLErrorsAsClasses
|
def _extractNVMLErrorsAsClasses():
"""
Generates a hierarchy of classes on top of NVMLError class.
Each NVML Error gets a new NVMLError subclass. This way try,except blocks
can filter appropriate exceptions more easily.
NVMLError is a parent class. Each NVML_ERROR_* gets it's own subclass. e.g.
NVML_ERROR_ALREADY_INITIALIZED will be turned into
NVMLError_AlreadyInitialized
"""
this_module = sys.modules[__name__]
nvmlErrorsNames = [x for x in dir(this_module) if x.startswith("NVML_ERROR_")]
for err_name in nvmlErrorsNames:
# e.g. Turn NVML_ERROR_ALREADY_INITIALIZED into NVMLError_AlreadyInitialized
class_name = "NVMLError_" + string.capwords(err_name.replace("NVML_ERROR_", ""), "_").replace("_", "")
err_val = getattr(this_module, err_name)
def gen_new(val):
def new(typ):
obj = NVMLError.__new__(typ, val)
return obj
return new
new_error_class = type(class_name, (NVMLError,), {'__new__': gen_new(err_val)})
new_error_class.__module__ = __name__
setattr(this_module, class_name, new_error_class)
NVMLError._valClassMapping[err_val] = new_error_class
|
python
|
def _extractNVMLErrorsAsClasses():
"""
Generates a hierarchy of classes on top of NVMLError class.
Each NVML Error gets a new NVMLError subclass. This way try,except blocks
can filter appropriate exceptions more easily.
NVMLError is a parent class. Each NVML_ERROR_* gets it's own subclass. e.g.
NVML_ERROR_ALREADY_INITIALIZED will be turned into
NVMLError_AlreadyInitialized
"""
this_module = sys.modules[__name__]
nvmlErrorsNames = [x for x in dir(this_module) if x.startswith("NVML_ERROR_")]
for err_name in nvmlErrorsNames:
# e.g. Turn NVML_ERROR_ALREADY_INITIALIZED into NVMLError_AlreadyInitialized
class_name = "NVMLError_" + string.capwords(err_name.replace("NVML_ERROR_", ""), "_").replace("_", "")
err_val = getattr(this_module, err_name)
def gen_new(val):
def new(typ):
obj = NVMLError.__new__(typ, val)
return obj
return new
new_error_class = type(class_name, (NVMLError,), {'__new__': gen_new(err_val)})
new_error_class.__module__ = __name__
setattr(this_module, class_name, new_error_class)
NVMLError._valClassMapping[err_val] = new_error_class
|
[
"def",
"_extractNVMLErrorsAsClasses",
"(",
")",
":",
"this_module",
"=",
"sys",
".",
"modules",
"[",
"__name__",
"]",
"nvmlErrorsNames",
"=",
"[",
"x",
"for",
"x",
"in",
"dir",
"(",
"this_module",
")",
"if",
"x",
".",
"startswith",
"(",
"\"NVML_ERROR_\"",
")",
"]",
"for",
"err_name",
"in",
"nvmlErrorsNames",
":",
"# e.g. Turn NVML_ERROR_ALREADY_INITIALIZED into NVMLError_AlreadyInitialized",
"class_name",
"=",
"\"NVMLError_\"",
"+",
"string",
".",
"capwords",
"(",
"err_name",
".",
"replace",
"(",
"\"NVML_ERROR_\"",
",",
"\"\"",
")",
",",
"\"_\"",
")",
".",
"replace",
"(",
"\"_\"",
",",
"\"\"",
")",
"err_val",
"=",
"getattr",
"(",
"this_module",
",",
"err_name",
")",
"def",
"gen_new",
"(",
"val",
")",
":",
"def",
"new",
"(",
"typ",
")",
":",
"obj",
"=",
"NVMLError",
".",
"__new__",
"(",
"typ",
",",
"val",
")",
"return",
"obj",
"return",
"new",
"new_error_class",
"=",
"type",
"(",
"class_name",
",",
"(",
"NVMLError",
",",
")",
",",
"{",
"'__new__'",
":",
"gen_new",
"(",
"err_val",
")",
"}",
")",
"new_error_class",
".",
"__module__",
"=",
"__name__",
"setattr",
"(",
"this_module",
",",
"class_name",
",",
"new_error_class",
")",
"NVMLError",
".",
"_valClassMapping",
"[",
"err_val",
"]",
"=",
"new_error_class"
] |
Generates a hierarchy of classes on top of NVMLError class.
Each NVML Error gets a new NVMLError subclass. This way try,except blocks
can filter appropriate exceptions more easily.
NVMLError is a parent class. Each NVML_ERROR_* gets it's own subclass. e.g.
NVML_ERROR_ALREADY_INITIALIZED will be turned into
NVMLError_AlreadyInitialized
|
[
"Generates",
"a",
"hierarchy",
"of",
"classes",
"on",
"top",
"of",
"NVMLError",
"class",
"."
] |
47f0f2c0eee56dec4e4beebec26b734e01d357b7
|
https://github.com/fbcotter/py3nvml/blob/47f0f2c0eee56dec4e4beebec26b734e01d357b7/py3nvml/py3nvml.py#L686-L711
|
11,255
|
fbcotter/py3nvml
|
py3nvml/py3nvml.py
|
_LoadNvmlLibrary
|
def _LoadNvmlLibrary():
"""
Load the library if it isn't loaded already
"""
global nvmlLib
if (nvmlLib is None):
# lock to ensure only one caller loads the library
libLoadLock.acquire()
try:
# ensure the library still isn't loaded
if (nvmlLib is None):
try:
if (sys.platform[:3] == "win"):
searchPaths = [
os.path.join(os.getenv("ProgramFiles", r"C:\Program Files"), r"NVIDIA Corporation\NVSMI\nvml.dll"),
os.path.join(os.getenv("WinDir", r"C:\Windows"), r"System32\nvml.dll"),
]
nvmlPath = next((x for x in searchPaths if os.path.isfile(x)), None)
if (nvmlPath == None):
_nvmlCheckReturn(NVML_ERROR_LIBRARY_NOT_FOUND)
else:
# cdecl calling convention
nvmlLib = CDLL(nvmlPath)
else:
# assume linux
nvmlLib = CDLL("libnvidia-ml.so.1")
except OSError as ose:
_nvmlCheckReturn(NVML_ERROR_LIBRARY_NOT_FOUND)
if (nvmlLib == None):
_nvmlCheckReturn(NVML_ERROR_LIBRARY_NOT_FOUND)
finally:
# lock is always freed
libLoadLock.release()
|
python
|
def _LoadNvmlLibrary():
"""
Load the library if it isn't loaded already
"""
global nvmlLib
if (nvmlLib is None):
# lock to ensure only one caller loads the library
libLoadLock.acquire()
try:
# ensure the library still isn't loaded
if (nvmlLib is None):
try:
if (sys.platform[:3] == "win"):
searchPaths = [
os.path.join(os.getenv("ProgramFiles", r"C:\Program Files"), r"NVIDIA Corporation\NVSMI\nvml.dll"),
os.path.join(os.getenv("WinDir", r"C:\Windows"), r"System32\nvml.dll"),
]
nvmlPath = next((x for x in searchPaths if os.path.isfile(x)), None)
if (nvmlPath == None):
_nvmlCheckReturn(NVML_ERROR_LIBRARY_NOT_FOUND)
else:
# cdecl calling convention
nvmlLib = CDLL(nvmlPath)
else:
# assume linux
nvmlLib = CDLL("libnvidia-ml.so.1")
except OSError as ose:
_nvmlCheckReturn(NVML_ERROR_LIBRARY_NOT_FOUND)
if (nvmlLib == None):
_nvmlCheckReturn(NVML_ERROR_LIBRARY_NOT_FOUND)
finally:
# lock is always freed
libLoadLock.release()
|
[
"def",
"_LoadNvmlLibrary",
"(",
")",
":",
"global",
"nvmlLib",
"if",
"(",
"nvmlLib",
"is",
"None",
")",
":",
"# lock to ensure only one caller loads the library",
"libLoadLock",
".",
"acquire",
"(",
")",
"try",
":",
"# ensure the library still isn't loaded",
"if",
"(",
"nvmlLib",
"is",
"None",
")",
":",
"try",
":",
"if",
"(",
"sys",
".",
"platform",
"[",
":",
"3",
"]",
"==",
"\"win\"",
")",
":",
"searchPaths",
"=",
"[",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"getenv",
"(",
"\"ProgramFiles\"",
",",
"r\"C:\\Program Files\"",
")",
",",
"r\"NVIDIA Corporation\\NVSMI\\nvml.dll\"",
")",
",",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"getenv",
"(",
"\"WinDir\"",
",",
"r\"C:\\Windows\"",
")",
",",
"r\"System32\\nvml.dll\"",
")",
",",
"]",
"nvmlPath",
"=",
"next",
"(",
"(",
"x",
"for",
"x",
"in",
"searchPaths",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"x",
")",
")",
",",
"None",
")",
"if",
"(",
"nvmlPath",
"==",
"None",
")",
":",
"_nvmlCheckReturn",
"(",
"NVML_ERROR_LIBRARY_NOT_FOUND",
")",
"else",
":",
"# cdecl calling convention",
"nvmlLib",
"=",
"CDLL",
"(",
"nvmlPath",
")",
"else",
":",
"# assume linux",
"nvmlLib",
"=",
"CDLL",
"(",
"\"libnvidia-ml.so.1\"",
")",
"except",
"OSError",
"as",
"ose",
":",
"_nvmlCheckReturn",
"(",
"NVML_ERROR_LIBRARY_NOT_FOUND",
")",
"if",
"(",
"nvmlLib",
"==",
"None",
")",
":",
"_nvmlCheckReturn",
"(",
"NVML_ERROR_LIBRARY_NOT_FOUND",
")",
"finally",
":",
"# lock is always freed",
"libLoadLock",
".",
"release",
"(",
")"
] |
Load the library if it isn't loaded already
|
[
"Load",
"the",
"library",
"if",
"it",
"isn",
"t",
"loaded",
"already"
] |
47f0f2c0eee56dec4e4beebec26b734e01d357b7
|
https://github.com/fbcotter/py3nvml/blob/47f0f2c0eee56dec4e4beebec26b734e01d357b7/py3nvml/py3nvml.py#L1104-L1138
|
11,256
|
samuraisam/pyapns
|
pyapns/server.py
|
encode_notifications
|
def encode_notifications(tokens, notifications):
""" Returns the encoded bytes of tokens and notifications
tokens a list of tokens or a string of only one token
notifications a list of notifications or a dictionary of only one
"""
fmt = "!BH32sH%ds"
structify = lambda t, p: struct.pack(fmt % len(p), 0, 32, t, len(p), p)
binaryify = lambda t: t.decode('hex')
if type(notifications) is dict and type(tokens) in (str, unicode):
tokens, notifications = ([tokens], [notifications])
if type(notifications) is list and type(tokens) is list:
return ''.join(map(lambda y: structify(*y), ((binaryify(t), json.dumps(p, separators=(',',':'), ensure_ascii=False).encode('utf-8'))
for t, p in zip(tokens, notifications))))
|
python
|
def encode_notifications(tokens, notifications):
""" Returns the encoded bytes of tokens and notifications
tokens a list of tokens or a string of only one token
notifications a list of notifications or a dictionary of only one
"""
fmt = "!BH32sH%ds"
structify = lambda t, p: struct.pack(fmt % len(p), 0, 32, t, len(p), p)
binaryify = lambda t: t.decode('hex')
if type(notifications) is dict and type(tokens) in (str, unicode):
tokens, notifications = ([tokens], [notifications])
if type(notifications) is list and type(tokens) is list:
return ''.join(map(lambda y: structify(*y), ((binaryify(t), json.dumps(p, separators=(',',':'), ensure_ascii=False).encode('utf-8'))
for t, p in zip(tokens, notifications))))
|
[
"def",
"encode_notifications",
"(",
"tokens",
",",
"notifications",
")",
":",
"fmt",
"=",
"\"!BH32sH%ds\"",
"structify",
"=",
"lambda",
"t",
",",
"p",
":",
"struct",
".",
"pack",
"(",
"fmt",
"%",
"len",
"(",
"p",
")",
",",
"0",
",",
"32",
",",
"t",
",",
"len",
"(",
"p",
")",
",",
"p",
")",
"binaryify",
"=",
"lambda",
"t",
":",
"t",
".",
"decode",
"(",
"'hex'",
")",
"if",
"type",
"(",
"notifications",
")",
"is",
"dict",
"and",
"type",
"(",
"tokens",
")",
"in",
"(",
"str",
",",
"unicode",
")",
":",
"tokens",
",",
"notifications",
"=",
"(",
"[",
"tokens",
"]",
",",
"[",
"notifications",
"]",
")",
"if",
"type",
"(",
"notifications",
")",
"is",
"list",
"and",
"type",
"(",
"tokens",
")",
"is",
"list",
":",
"return",
"''",
".",
"join",
"(",
"map",
"(",
"lambda",
"y",
":",
"structify",
"(",
"*",
"y",
")",
",",
"(",
"(",
"binaryify",
"(",
"t",
")",
",",
"json",
".",
"dumps",
"(",
"p",
",",
"separators",
"=",
"(",
"','",
",",
"':'",
")",
",",
"ensure_ascii",
"=",
"False",
")",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"for",
"t",
",",
"p",
"in",
"zip",
"(",
"tokens",
",",
"notifications",
")",
")",
")",
")"
] |
Returns the encoded bytes of tokens and notifications
tokens a list of tokens or a string of only one token
notifications a list of notifications or a dictionary of only one
|
[
"Returns",
"the",
"encoded",
"bytes",
"of",
"tokens",
"and",
"notifications",
"tokens",
"a",
"list",
"of",
"tokens",
"or",
"a",
"string",
"of",
"only",
"one",
"token",
"notifications",
"a",
"list",
"of",
"notifications",
"or",
"a",
"dictionary",
"of",
"only",
"one"
] |
78c1875f28f8af51c7dd7f60d4436a8b282b0394
|
https://github.com/samuraisam/pyapns/blob/78c1875f28f8af51c7dd7f60d4436a8b282b0394/pyapns/server.py#L317-L331
|
11,257
|
samuraisam/pyapns
|
pyapns/server.py
|
APNSService.write
|
def write(self, notifications):
"Connect to the APNS service and send notifications"
if not self.factory:
log.msg('APNSService write (connecting)')
server, port = ((APNS_SERVER_SANDBOX_HOSTNAME
if self.environment == 'sandbox'
else APNS_SERVER_HOSTNAME), APNS_SERVER_PORT)
self.factory = self.clientProtocolFactory()
context = self.getContextFactory()
reactor.connectSSL(server, port, self.factory, context)
client = self.factory.clientProtocol
if client:
return client.sendMessage(notifications)
else:
d = self.factory.deferred
timeout = reactor.callLater(self.timeout,
lambda: d.called or d.errback(
Exception('Notification timed out after %i seconds' % self.timeout)))
def cancel_timeout(r):
try: timeout.cancel()
except: pass
return r
d.addCallback(lambda p: p.sendMessage(notifications))
d.addErrback(log_errback('apns-service-write'))
d.addBoth(cancel_timeout)
return d
|
python
|
def write(self, notifications):
"Connect to the APNS service and send notifications"
if not self.factory:
log.msg('APNSService write (connecting)')
server, port = ((APNS_SERVER_SANDBOX_HOSTNAME
if self.environment == 'sandbox'
else APNS_SERVER_HOSTNAME), APNS_SERVER_PORT)
self.factory = self.clientProtocolFactory()
context = self.getContextFactory()
reactor.connectSSL(server, port, self.factory, context)
client = self.factory.clientProtocol
if client:
return client.sendMessage(notifications)
else:
d = self.factory.deferred
timeout = reactor.callLater(self.timeout,
lambda: d.called or d.errback(
Exception('Notification timed out after %i seconds' % self.timeout)))
def cancel_timeout(r):
try: timeout.cancel()
except: pass
return r
d.addCallback(lambda p: p.sendMessage(notifications))
d.addErrback(log_errback('apns-service-write'))
d.addBoth(cancel_timeout)
return d
|
[
"def",
"write",
"(",
"self",
",",
"notifications",
")",
":",
"if",
"not",
"self",
".",
"factory",
":",
"log",
".",
"msg",
"(",
"'APNSService write (connecting)'",
")",
"server",
",",
"port",
"=",
"(",
"(",
"APNS_SERVER_SANDBOX_HOSTNAME",
"if",
"self",
".",
"environment",
"==",
"'sandbox'",
"else",
"APNS_SERVER_HOSTNAME",
")",
",",
"APNS_SERVER_PORT",
")",
"self",
".",
"factory",
"=",
"self",
".",
"clientProtocolFactory",
"(",
")",
"context",
"=",
"self",
".",
"getContextFactory",
"(",
")",
"reactor",
".",
"connectSSL",
"(",
"server",
",",
"port",
",",
"self",
".",
"factory",
",",
"context",
")",
"client",
"=",
"self",
".",
"factory",
".",
"clientProtocol",
"if",
"client",
":",
"return",
"client",
".",
"sendMessage",
"(",
"notifications",
")",
"else",
":",
"d",
"=",
"self",
".",
"factory",
".",
"deferred",
"timeout",
"=",
"reactor",
".",
"callLater",
"(",
"self",
".",
"timeout",
",",
"lambda",
":",
"d",
".",
"called",
"or",
"d",
".",
"errback",
"(",
"Exception",
"(",
"'Notification timed out after %i seconds'",
"%",
"self",
".",
"timeout",
")",
")",
")",
"def",
"cancel_timeout",
"(",
"r",
")",
":",
"try",
":",
"timeout",
".",
"cancel",
"(",
")",
"except",
":",
"pass",
"return",
"r",
"d",
".",
"addCallback",
"(",
"lambda",
"p",
":",
"p",
".",
"sendMessage",
"(",
"notifications",
")",
")",
"d",
".",
"addErrback",
"(",
"log_errback",
"(",
"'apns-service-write'",
")",
")",
"d",
".",
"addBoth",
"(",
"cancel_timeout",
")",
"return",
"d"
] |
Connect to the APNS service and send notifications
|
[
"Connect",
"to",
"the",
"APNS",
"service",
"and",
"send",
"notifications"
] |
78c1875f28f8af51c7dd7f60d4436a8b282b0394
|
https://github.com/samuraisam/pyapns/blob/78c1875f28f8af51c7dd7f60d4436a8b282b0394/pyapns/server.py#L186-L213
|
11,258
|
samuraisam/pyapns
|
pyapns/server.py
|
APNSService.read
|
def read(self):
"Connect to the feedback service and read all data."
log.msg('APNSService read (connecting)')
try:
server, port = ((FEEDBACK_SERVER_SANDBOX_HOSTNAME
if self.environment == 'sandbox'
else FEEDBACK_SERVER_HOSTNAME), FEEDBACK_SERVER_PORT)
factory = self.feedbackProtocolFactory()
context = self.getContextFactory()
reactor.connectSSL(server, port, factory, context)
factory.deferred.addErrback(log_errback('apns-feedback-read'))
timeout = reactor.callLater(self.timeout,
lambda: factory.deferred.called or factory.deferred.errback(
Exception('Feedbcak fetch timed out after %i seconds' % self.timeout)))
def cancel_timeout(r):
try: timeout.cancel()
except: pass
return r
factory.deferred.addBoth(cancel_timeout)
except Exception, e:
log.err('APNService feedback error initializing: %s' % str(e))
raise
return factory.deferred
|
python
|
def read(self):
"Connect to the feedback service and read all data."
log.msg('APNSService read (connecting)')
try:
server, port = ((FEEDBACK_SERVER_SANDBOX_HOSTNAME
if self.environment == 'sandbox'
else FEEDBACK_SERVER_HOSTNAME), FEEDBACK_SERVER_PORT)
factory = self.feedbackProtocolFactory()
context = self.getContextFactory()
reactor.connectSSL(server, port, factory, context)
factory.deferred.addErrback(log_errback('apns-feedback-read'))
timeout = reactor.callLater(self.timeout,
lambda: factory.deferred.called or factory.deferred.errback(
Exception('Feedbcak fetch timed out after %i seconds' % self.timeout)))
def cancel_timeout(r):
try: timeout.cancel()
except: pass
return r
factory.deferred.addBoth(cancel_timeout)
except Exception, e:
log.err('APNService feedback error initializing: %s' % str(e))
raise
return factory.deferred
|
[
"def",
"read",
"(",
"self",
")",
":",
"log",
".",
"msg",
"(",
"'APNSService read (connecting)'",
")",
"try",
":",
"server",
",",
"port",
"=",
"(",
"(",
"FEEDBACK_SERVER_SANDBOX_HOSTNAME",
"if",
"self",
".",
"environment",
"==",
"'sandbox'",
"else",
"FEEDBACK_SERVER_HOSTNAME",
")",
",",
"FEEDBACK_SERVER_PORT",
")",
"factory",
"=",
"self",
".",
"feedbackProtocolFactory",
"(",
")",
"context",
"=",
"self",
".",
"getContextFactory",
"(",
")",
"reactor",
".",
"connectSSL",
"(",
"server",
",",
"port",
",",
"factory",
",",
"context",
")",
"factory",
".",
"deferred",
".",
"addErrback",
"(",
"log_errback",
"(",
"'apns-feedback-read'",
")",
")",
"timeout",
"=",
"reactor",
".",
"callLater",
"(",
"self",
".",
"timeout",
",",
"lambda",
":",
"factory",
".",
"deferred",
".",
"called",
"or",
"factory",
".",
"deferred",
".",
"errback",
"(",
"Exception",
"(",
"'Feedbcak fetch timed out after %i seconds'",
"%",
"self",
".",
"timeout",
")",
")",
")",
"def",
"cancel_timeout",
"(",
"r",
")",
":",
"try",
":",
"timeout",
".",
"cancel",
"(",
")",
"except",
":",
"pass",
"return",
"r",
"factory",
".",
"deferred",
".",
"addBoth",
"(",
"cancel_timeout",
")",
"except",
"Exception",
",",
"e",
":",
"log",
".",
"err",
"(",
"'APNService feedback error initializing: %s'",
"%",
"str",
"(",
"e",
")",
")",
"raise",
"return",
"factory",
".",
"deferred"
] |
Connect to the feedback service and read all data.
|
[
"Connect",
"to",
"the",
"feedback",
"service",
"and",
"read",
"all",
"data",
"."
] |
78c1875f28f8af51c7dd7f60d4436a8b282b0394
|
https://github.com/samuraisam/pyapns/blob/78c1875f28f8af51c7dd7f60d4436a8b282b0394/pyapns/server.py#L215-L239
|
11,259
|
samuraisam/pyapns
|
pyapns/client.py
|
reprovision_and_retry
|
def reprovision_and_retry(func):
"""
Wraps the `errback` callback of the API functions, automatically trying to
re-provision if the app ID can not be found during the operation. If that's
unsuccessful, it will raise the UnknownAppID error.
"""
@functools.wraps(func)
def wrapper(*a, **kw):
errback = kw.get('errback', None)
if errback is None:
def errback(e):
raise e
def errback_wrapper(e):
if isinstance(e, UnknownAppID) and 'INITIAL' in OPTIONS:
try:
for initial in OPTIONS['INITIAL']:
provision(*initial) # retry provisioning the initial setup
func(*a, **kw) # and try the function once more
except Exception, new_exc:
errback(new_exc) # throwing the new exception
else:
errback(e) # not an instance of UnknownAppID - nothing we can do here
kw['errback'] = errback_wrapper
return func(*a, **kw)
return wrapper
|
python
|
def reprovision_and_retry(func):
"""
Wraps the `errback` callback of the API functions, automatically trying to
re-provision if the app ID can not be found during the operation. If that's
unsuccessful, it will raise the UnknownAppID error.
"""
@functools.wraps(func)
def wrapper(*a, **kw):
errback = kw.get('errback', None)
if errback is None:
def errback(e):
raise e
def errback_wrapper(e):
if isinstance(e, UnknownAppID) and 'INITIAL' in OPTIONS:
try:
for initial in OPTIONS['INITIAL']:
provision(*initial) # retry provisioning the initial setup
func(*a, **kw) # and try the function once more
except Exception, new_exc:
errback(new_exc) # throwing the new exception
else:
errback(e) # not an instance of UnknownAppID - nothing we can do here
kw['errback'] = errback_wrapper
return func(*a, **kw)
return wrapper
|
[
"def",
"reprovision_and_retry",
"(",
"func",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"func",
")",
"def",
"wrapper",
"(",
"*",
"a",
",",
"*",
"*",
"kw",
")",
":",
"errback",
"=",
"kw",
".",
"get",
"(",
"'errback'",
",",
"None",
")",
"if",
"errback",
"is",
"None",
":",
"def",
"errback",
"(",
"e",
")",
":",
"raise",
"e",
"def",
"errback_wrapper",
"(",
"e",
")",
":",
"if",
"isinstance",
"(",
"e",
",",
"UnknownAppID",
")",
"and",
"'INITIAL'",
"in",
"OPTIONS",
":",
"try",
":",
"for",
"initial",
"in",
"OPTIONS",
"[",
"'INITIAL'",
"]",
":",
"provision",
"(",
"*",
"initial",
")",
"# retry provisioning the initial setup",
"func",
"(",
"*",
"a",
",",
"*",
"*",
"kw",
")",
"# and try the function once more",
"except",
"Exception",
",",
"new_exc",
":",
"errback",
"(",
"new_exc",
")",
"# throwing the new exception",
"else",
":",
"errback",
"(",
"e",
")",
"# not an instance of UnknownAppID - nothing we can do here",
"kw",
"[",
"'errback'",
"]",
"=",
"errback_wrapper",
"return",
"func",
"(",
"*",
"a",
",",
"*",
"*",
"kw",
")",
"return",
"wrapper"
] |
Wraps the `errback` callback of the API functions, automatically trying to
re-provision if the app ID can not be found during the operation. If that's
unsuccessful, it will raise the UnknownAppID error.
|
[
"Wraps",
"the",
"errback",
"callback",
"of",
"the",
"API",
"functions",
"automatically",
"trying",
"to",
"re",
"-",
"provision",
"if",
"the",
"app",
"ID",
"can",
"not",
"be",
"found",
"during",
"the",
"operation",
".",
"If",
"that",
"s",
"unsuccessful",
"it",
"will",
"raise",
"the",
"UnknownAppID",
"error",
"."
] |
78c1875f28f8af51c7dd7f60d4436a8b282b0394
|
https://github.com/samuraisam/pyapns/blob/78c1875f28f8af51c7dd7f60d4436a8b282b0394/pyapns/client.py#L44-L68
|
11,260
|
timothycrosley/jiphy
|
jiphy/parser.py
|
Parser.pop
|
def pop(self):
"""removes the current character then moves to the next one, returning the current character"""
char = self.code[self.index]
self.index += 1
return char
|
python
|
def pop(self):
"""removes the current character then moves to the next one, returning the current character"""
char = self.code[self.index]
self.index += 1
return char
|
[
"def",
"pop",
"(",
"self",
")",
":",
"char",
"=",
"self",
".",
"code",
"[",
"self",
".",
"index",
"]",
"self",
".",
"index",
"+=",
"1",
"return",
"char"
] |
removes the current character then moves to the next one, returning the current character
|
[
"removes",
"the",
"current",
"character",
"then",
"moves",
"to",
"the",
"next",
"one",
"returning",
"the",
"current",
"character"
] |
6e09be9c3496ca40901df70fc9b14d2ca3ec2e04
|
https://github.com/timothycrosley/jiphy/blob/6e09be9c3496ca40901df70fc9b14d2ca3ec2e04/jiphy/parser.py#L83-L87
|
11,261
|
timothycrosley/jiphy
|
jiphy/parser.py
|
Parser.characters
|
def characters(self, numberOfCharacters):
"""Returns characters at index + number of characters"""
return self.code[self.index:self.index + numberOfCharacters]
|
python
|
def characters(self, numberOfCharacters):
"""Returns characters at index + number of characters"""
return self.code[self.index:self.index + numberOfCharacters]
|
[
"def",
"characters",
"(",
"self",
",",
"numberOfCharacters",
")",
":",
"return",
"self",
".",
"code",
"[",
"self",
".",
"index",
":",
"self",
".",
"index",
"+",
"numberOfCharacters",
"]"
] |
Returns characters at index + number of characters
|
[
"Returns",
"characters",
"at",
"index",
"+",
"number",
"of",
"characters"
] |
6e09be9c3496ca40901df70fc9b14d2ca3ec2e04
|
https://github.com/timothycrosley/jiphy/blob/6e09be9c3496ca40901df70fc9b14d2ca3ec2e04/jiphy/parser.py#L89-L91
|
11,262
|
timothycrosley/jiphy
|
jiphy/parser.py
|
Parser.next_content
|
def next_content(self, start, amount=1):
"""Returns the next non-whitespace characters"""
while start < len(self.code) and self.code[start] in (' ', '\t', '\n'):
start += 1
return self.code[start: start + amount]
|
python
|
def next_content(self, start, amount=1):
"""Returns the next non-whitespace characters"""
while start < len(self.code) and self.code[start] in (' ', '\t', '\n'):
start += 1
return self.code[start: start + amount]
|
[
"def",
"next_content",
"(",
"self",
",",
"start",
",",
"amount",
"=",
"1",
")",
":",
"while",
"start",
"<",
"len",
"(",
"self",
".",
"code",
")",
"and",
"self",
".",
"code",
"[",
"start",
"]",
"in",
"(",
"' '",
",",
"'\\t'",
",",
"'\\n'",
")",
":",
"start",
"+=",
"1",
"return",
"self",
".",
"code",
"[",
"start",
":",
"start",
"+",
"amount",
"]"
] |
Returns the next non-whitespace characters
|
[
"Returns",
"the",
"next",
"non",
"-",
"whitespace",
"characters"
] |
6e09be9c3496ca40901df70fc9b14d2ca3ec2e04
|
https://github.com/timothycrosley/jiphy/blob/6e09be9c3496ca40901df70fc9b14d2ca3ec2e04/jiphy/parser.py#L117-L122
|
11,263
|
timothycrosley/jiphy
|
jiphy/parser.py
|
Parser.prev_content
|
def prev_content(self, start, amount=1):
"""Returns the prev non-whitespace characters"""
while start > 0 and self.code[start] in (' ', '\t', '\n'):
start -= 1
return self.code[(start or amount) - amount: start]
|
python
|
def prev_content(self, start, amount=1):
"""Returns the prev non-whitespace characters"""
while start > 0 and self.code[start] in (' ', '\t', '\n'):
start -= 1
return self.code[(start or amount) - amount: start]
|
[
"def",
"prev_content",
"(",
"self",
",",
"start",
",",
"amount",
"=",
"1",
")",
":",
"while",
"start",
">",
"0",
"and",
"self",
".",
"code",
"[",
"start",
"]",
"in",
"(",
"' '",
",",
"'\\t'",
",",
"'\\n'",
")",
":",
"start",
"-=",
"1",
"return",
"self",
".",
"code",
"[",
"(",
"start",
"or",
"amount",
")",
"-",
"amount",
":",
"start",
"]"
] |
Returns the prev non-whitespace characters
|
[
"Returns",
"the",
"prev",
"non",
"-",
"whitespace",
"characters"
] |
6e09be9c3496ca40901df70fc9b14d2ca3ec2e04
|
https://github.com/timothycrosley/jiphy/blob/6e09be9c3496ca40901df70fc9b14d2ca3ec2e04/jiphy/parser.py#L124-L129
|
11,264
|
languitar/pass-git-helper
|
passgithelper.py
|
parse_mapping
|
def parse_mapping(mapping_file: Optional[str]) -> configparser.ConfigParser:
"""
Parse the file containing the mappings from hosts to pass entries.
Args:
mapping_file:
Name of the file to parse. If ``None``, the default file from the
XDG location is used.
"""
LOGGER.debug('Parsing mapping file. Command line: %s', mapping_file)
def parse(mapping_file):
config = configparser.ConfigParser()
config.read_file(mapping_file)
return config
# give precedence to the user-specified file
if mapping_file is not None:
LOGGER.debug('Parsing command line mapping file')
return parse(mapping_file)
# fall back on XDG config location
xdg_config_dir = xdg.BaseDirectory.load_first_config('pass-git-helper')
if xdg_config_dir is None:
raise RuntimeError(
'No mapping configured so far at any XDG config location. '
'Please create {config_file}'.format(
config_file=DEFAULT_CONFIG_FILE))
mapping_file = os.path.join(xdg_config_dir, CONFIG_FILE_NAME)
LOGGER.debug('Parsing mapping file %s', mapping_file)
with open(mapping_file, 'r') as file_handle:
return parse(file_handle)
|
python
|
def parse_mapping(mapping_file: Optional[str]) -> configparser.ConfigParser:
"""
Parse the file containing the mappings from hosts to pass entries.
Args:
mapping_file:
Name of the file to parse. If ``None``, the default file from the
XDG location is used.
"""
LOGGER.debug('Parsing mapping file. Command line: %s', mapping_file)
def parse(mapping_file):
config = configparser.ConfigParser()
config.read_file(mapping_file)
return config
# give precedence to the user-specified file
if mapping_file is not None:
LOGGER.debug('Parsing command line mapping file')
return parse(mapping_file)
# fall back on XDG config location
xdg_config_dir = xdg.BaseDirectory.load_first_config('pass-git-helper')
if xdg_config_dir is None:
raise RuntimeError(
'No mapping configured so far at any XDG config location. '
'Please create {config_file}'.format(
config_file=DEFAULT_CONFIG_FILE))
mapping_file = os.path.join(xdg_config_dir, CONFIG_FILE_NAME)
LOGGER.debug('Parsing mapping file %s', mapping_file)
with open(mapping_file, 'r') as file_handle:
return parse(file_handle)
|
[
"def",
"parse_mapping",
"(",
"mapping_file",
":",
"Optional",
"[",
"str",
"]",
")",
"->",
"configparser",
".",
"ConfigParser",
":",
"LOGGER",
".",
"debug",
"(",
"'Parsing mapping file. Command line: %s'",
",",
"mapping_file",
")",
"def",
"parse",
"(",
"mapping_file",
")",
":",
"config",
"=",
"configparser",
".",
"ConfigParser",
"(",
")",
"config",
".",
"read_file",
"(",
"mapping_file",
")",
"return",
"config",
"# give precedence to the user-specified file",
"if",
"mapping_file",
"is",
"not",
"None",
":",
"LOGGER",
".",
"debug",
"(",
"'Parsing command line mapping file'",
")",
"return",
"parse",
"(",
"mapping_file",
")",
"# fall back on XDG config location",
"xdg_config_dir",
"=",
"xdg",
".",
"BaseDirectory",
".",
"load_first_config",
"(",
"'pass-git-helper'",
")",
"if",
"xdg_config_dir",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'No mapping configured so far at any XDG config location. '",
"'Please create {config_file}'",
".",
"format",
"(",
"config_file",
"=",
"DEFAULT_CONFIG_FILE",
")",
")",
"mapping_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"xdg_config_dir",
",",
"CONFIG_FILE_NAME",
")",
"LOGGER",
".",
"debug",
"(",
"'Parsing mapping file %s'",
",",
"mapping_file",
")",
"with",
"open",
"(",
"mapping_file",
",",
"'r'",
")",
"as",
"file_handle",
":",
"return",
"parse",
"(",
"file_handle",
")"
] |
Parse the file containing the mappings from hosts to pass entries.
Args:
mapping_file:
Name of the file to parse. If ``None``, the default file from the
XDG location is used.
|
[
"Parse",
"the",
"file",
"containing",
"the",
"mappings",
"from",
"hosts",
"to",
"pass",
"entries",
"."
] |
f84376d9ed6f7c47454a499da103da6fc2575a25
|
https://github.com/languitar/pass-git-helper/blob/f84376d9ed6f7c47454a499da103da6fc2575a25/passgithelper.py#L73-L104
|
11,265
|
languitar/pass-git-helper
|
passgithelper.py
|
parse_request
|
def parse_request() -> Dict[str, str]:
"""
Parse the request of the git credential API from stdin.
Returns:
A dictionary with all key-value pairs of the request
"""
in_lines = sys.stdin.readlines()
LOGGER.debug('Received request "%s"', in_lines)
request = {}
for line in in_lines:
# skip empty lines to be a bit resilient against protocol errors
if not line.strip():
continue
parts = line.split('=', 1)
assert len(parts) == 2
request[parts[0].strip()] = parts[1].strip()
return request
|
python
|
def parse_request() -> Dict[str, str]:
"""
Parse the request of the git credential API from stdin.
Returns:
A dictionary with all key-value pairs of the request
"""
in_lines = sys.stdin.readlines()
LOGGER.debug('Received request "%s"', in_lines)
request = {}
for line in in_lines:
# skip empty lines to be a bit resilient against protocol errors
if not line.strip():
continue
parts = line.split('=', 1)
assert len(parts) == 2
request[parts[0].strip()] = parts[1].strip()
return request
|
[
"def",
"parse_request",
"(",
")",
"->",
"Dict",
"[",
"str",
",",
"str",
"]",
":",
"in_lines",
"=",
"sys",
".",
"stdin",
".",
"readlines",
"(",
")",
"LOGGER",
".",
"debug",
"(",
"'Received request \"%s\"'",
",",
"in_lines",
")",
"request",
"=",
"{",
"}",
"for",
"line",
"in",
"in_lines",
":",
"# skip empty lines to be a bit resilient against protocol errors",
"if",
"not",
"line",
".",
"strip",
"(",
")",
":",
"continue",
"parts",
"=",
"line",
".",
"split",
"(",
"'='",
",",
"1",
")",
"assert",
"len",
"(",
"parts",
")",
"==",
"2",
"request",
"[",
"parts",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"]",
"=",
"parts",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"return",
"request"
] |
Parse the request of the git credential API from stdin.
Returns:
A dictionary with all key-value pairs of the request
|
[
"Parse",
"the",
"request",
"of",
"the",
"git",
"credential",
"API",
"from",
"stdin",
"."
] |
f84376d9ed6f7c47454a499da103da6fc2575a25
|
https://github.com/languitar/pass-git-helper/blob/f84376d9ed6f7c47454a499da103da6fc2575a25/passgithelper.py#L107-L127
|
11,266
|
languitar/pass-git-helper
|
passgithelper.py
|
get_password
|
def get_password(request, mapping) -> None:
"""
Resolve the given credential request in the provided mapping definition.
The result is printed automatically.
Args:
request:
The credential request specified as a dict of key-value pairs.
mapping:
The mapping configuration as a ConfigParser instance.
"""
LOGGER.debug('Received request "%s"', request)
if 'host' not in request:
LOGGER.error('host= entry missing in request. '
'Cannot query without a host')
return
host = request['host']
if 'path' in request:
host = '/'.join([host, request['path']])
def skip(line, skip):
return line[skip:]
LOGGER.debug('Iterating mapping to match against host "%s"', host)
for section in mapping.sections():
if fnmatch.fnmatch(host, section):
LOGGER.debug('Section "%s" matches requested host "%s"',
section, host)
# TODO handle exceptions
pass_target = mapping.get(section, 'target').replace(
"${host}", request['host'])
password_extractor = SpecificLineExtractor(
0, 0, option_suffix='_password')
password_extractor.configure(mapping[section])
# username_extractor = SpecificLineExtractor(
# 1, 0, option_suffix='_username')
username_extractor = _username_extractors[mapping[section].get(
'username_extractor', fallback=_line_extractor_name)]
username_extractor.configure(mapping[section])
LOGGER.debug('Requesting entry "%s" from pass', pass_target)
output = subprocess.check_output(
['pass', 'show', pass_target]).decode('utf-8')
lines = output.splitlines()
password = password_extractor.get_value(pass_target, lines)
username = username_extractor.get_value(pass_target, lines)
if password:
print('password={password}'.format( # noqa: T001
password=password))
if 'username' not in request and username:
print('username={username}'.format( # noqa: T001
username=username))
return
LOGGER.warning('No mapping matched')
sys.exit(1)
|
python
|
def get_password(request, mapping) -> None:
"""
Resolve the given credential request in the provided mapping definition.
The result is printed automatically.
Args:
request:
The credential request specified as a dict of key-value pairs.
mapping:
The mapping configuration as a ConfigParser instance.
"""
LOGGER.debug('Received request "%s"', request)
if 'host' not in request:
LOGGER.error('host= entry missing in request. '
'Cannot query without a host')
return
host = request['host']
if 'path' in request:
host = '/'.join([host, request['path']])
def skip(line, skip):
return line[skip:]
LOGGER.debug('Iterating mapping to match against host "%s"', host)
for section in mapping.sections():
if fnmatch.fnmatch(host, section):
LOGGER.debug('Section "%s" matches requested host "%s"',
section, host)
# TODO handle exceptions
pass_target = mapping.get(section, 'target').replace(
"${host}", request['host'])
password_extractor = SpecificLineExtractor(
0, 0, option_suffix='_password')
password_extractor.configure(mapping[section])
# username_extractor = SpecificLineExtractor(
# 1, 0, option_suffix='_username')
username_extractor = _username_extractors[mapping[section].get(
'username_extractor', fallback=_line_extractor_name)]
username_extractor.configure(mapping[section])
LOGGER.debug('Requesting entry "%s" from pass', pass_target)
output = subprocess.check_output(
['pass', 'show', pass_target]).decode('utf-8')
lines = output.splitlines()
password = password_extractor.get_value(pass_target, lines)
username = username_extractor.get_value(pass_target, lines)
if password:
print('password={password}'.format( # noqa: T001
password=password))
if 'username' not in request and username:
print('username={username}'.format( # noqa: T001
username=username))
return
LOGGER.warning('No mapping matched')
sys.exit(1)
|
[
"def",
"get_password",
"(",
"request",
",",
"mapping",
")",
"->",
"None",
":",
"LOGGER",
".",
"debug",
"(",
"'Received request \"%s\"'",
",",
"request",
")",
"if",
"'host'",
"not",
"in",
"request",
":",
"LOGGER",
".",
"error",
"(",
"'host= entry missing in request. '",
"'Cannot query without a host'",
")",
"return",
"host",
"=",
"request",
"[",
"'host'",
"]",
"if",
"'path'",
"in",
"request",
":",
"host",
"=",
"'/'",
".",
"join",
"(",
"[",
"host",
",",
"request",
"[",
"'path'",
"]",
"]",
")",
"def",
"skip",
"(",
"line",
",",
"skip",
")",
":",
"return",
"line",
"[",
"skip",
":",
"]",
"LOGGER",
".",
"debug",
"(",
"'Iterating mapping to match against host \"%s\"'",
",",
"host",
")",
"for",
"section",
"in",
"mapping",
".",
"sections",
"(",
")",
":",
"if",
"fnmatch",
".",
"fnmatch",
"(",
"host",
",",
"section",
")",
":",
"LOGGER",
".",
"debug",
"(",
"'Section \"%s\" matches requested host \"%s\"'",
",",
"section",
",",
"host",
")",
"# TODO handle exceptions",
"pass_target",
"=",
"mapping",
".",
"get",
"(",
"section",
",",
"'target'",
")",
".",
"replace",
"(",
"\"${host}\"",
",",
"request",
"[",
"'host'",
"]",
")",
"password_extractor",
"=",
"SpecificLineExtractor",
"(",
"0",
",",
"0",
",",
"option_suffix",
"=",
"'_password'",
")",
"password_extractor",
".",
"configure",
"(",
"mapping",
"[",
"section",
"]",
")",
"# username_extractor = SpecificLineExtractor(",
"# 1, 0, option_suffix='_username')",
"username_extractor",
"=",
"_username_extractors",
"[",
"mapping",
"[",
"section",
"]",
".",
"get",
"(",
"'username_extractor'",
",",
"fallback",
"=",
"_line_extractor_name",
")",
"]",
"username_extractor",
".",
"configure",
"(",
"mapping",
"[",
"section",
"]",
")",
"LOGGER",
".",
"debug",
"(",
"'Requesting entry \"%s\" from pass'",
",",
"pass_target",
")",
"output",
"=",
"subprocess",
".",
"check_output",
"(",
"[",
"'pass'",
",",
"'show'",
",",
"pass_target",
"]",
")",
".",
"decode",
"(",
"'utf-8'",
")",
"lines",
"=",
"output",
".",
"splitlines",
"(",
")",
"password",
"=",
"password_extractor",
".",
"get_value",
"(",
"pass_target",
",",
"lines",
")",
"username",
"=",
"username_extractor",
".",
"get_value",
"(",
"pass_target",
",",
"lines",
")",
"if",
"password",
":",
"print",
"(",
"'password={password}'",
".",
"format",
"(",
"# noqa: T001",
"password",
"=",
"password",
")",
")",
"if",
"'username'",
"not",
"in",
"request",
"and",
"username",
":",
"print",
"(",
"'username={username}'",
".",
"format",
"(",
"# noqa: T001",
"username",
"=",
"username",
")",
")",
"return",
"LOGGER",
".",
"warning",
"(",
"'No mapping matched'",
")",
"sys",
".",
"exit",
"(",
"1",
")"
] |
Resolve the given credential request in the provided mapping definition.
The result is printed automatically.
Args:
request:
The credential request specified as a dict of key-value pairs.
mapping:
The mapping configuration as a ConfigParser instance.
|
[
"Resolve",
"the",
"given",
"credential",
"request",
"in",
"the",
"provided",
"mapping",
"definition",
"."
] |
f84376d9ed6f7c47454a499da103da6fc2575a25
|
https://github.com/languitar/pass-git-helper/blob/f84376d9ed6f7c47454a499da103da6fc2575a25/passgithelper.py#L324-L383
|
11,267
|
languitar/pass-git-helper
|
passgithelper.py
|
main
|
def main(argv: Optional[Sequence[str]] = None) -> None:
"""
Start the pass-git-helper script.
Args:
argv:
If not ``None``, use the provided command line arguments for
parsing. Otherwise, extract them automatically.
"""
args = parse_arguments(argv=argv)
if args.logging:
logging.basicConfig(level=logging.DEBUG)
handle_skip()
action = args.action
request = parse_request()
LOGGER.debug('Received action %s with request:\n%s',
action, request)
try:
mapping = parse_mapping(args.mapping)
except Exception as error:
LOGGER.critical('Unable to parse mapping file', exc_info=True)
print( # noqa: P101
'Unable to parse mapping file: {error}'.format(
error=error),
file=sys.stderr)
sys.exit(1)
if action == 'get':
get_password(request, mapping)
else:
LOGGER.info('Action %s is currently not supported', action)
sys.exit(1)
|
python
|
def main(argv: Optional[Sequence[str]] = None) -> None:
"""
Start the pass-git-helper script.
Args:
argv:
If not ``None``, use the provided command line arguments for
parsing. Otherwise, extract them automatically.
"""
args = parse_arguments(argv=argv)
if args.logging:
logging.basicConfig(level=logging.DEBUG)
handle_skip()
action = args.action
request = parse_request()
LOGGER.debug('Received action %s with request:\n%s',
action, request)
try:
mapping = parse_mapping(args.mapping)
except Exception as error:
LOGGER.critical('Unable to parse mapping file', exc_info=True)
print( # noqa: P101
'Unable to parse mapping file: {error}'.format(
error=error),
file=sys.stderr)
sys.exit(1)
if action == 'get':
get_password(request, mapping)
else:
LOGGER.info('Action %s is currently not supported', action)
sys.exit(1)
|
[
"def",
"main",
"(",
"argv",
":",
"Optional",
"[",
"Sequence",
"[",
"str",
"]",
"]",
"=",
"None",
")",
"->",
"None",
":",
"args",
"=",
"parse_arguments",
"(",
"argv",
"=",
"argv",
")",
"if",
"args",
".",
"logging",
":",
"logging",
".",
"basicConfig",
"(",
"level",
"=",
"logging",
".",
"DEBUG",
")",
"handle_skip",
"(",
")",
"action",
"=",
"args",
".",
"action",
"request",
"=",
"parse_request",
"(",
")",
"LOGGER",
".",
"debug",
"(",
"'Received action %s with request:\\n%s'",
",",
"action",
",",
"request",
")",
"try",
":",
"mapping",
"=",
"parse_mapping",
"(",
"args",
".",
"mapping",
")",
"except",
"Exception",
"as",
"error",
":",
"LOGGER",
".",
"critical",
"(",
"'Unable to parse mapping file'",
",",
"exc_info",
"=",
"True",
")",
"print",
"(",
"# noqa: P101",
"'Unable to parse mapping file: {error}'",
".",
"format",
"(",
"error",
"=",
"error",
")",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"if",
"action",
"==",
"'get'",
":",
"get_password",
"(",
"request",
",",
"mapping",
")",
"else",
":",
"LOGGER",
".",
"info",
"(",
"'Action %s is currently not supported'",
",",
"action",
")",
"sys",
".",
"exit",
"(",
"1",
")"
] |
Start the pass-git-helper script.
Args:
argv:
If not ``None``, use the provided command line arguments for
parsing. Otherwise, extract them automatically.
|
[
"Start",
"the",
"pass",
"-",
"git",
"-",
"helper",
"script",
"."
] |
f84376d9ed6f7c47454a499da103da6fc2575a25
|
https://github.com/languitar/pass-git-helper/blob/f84376d9ed6f7c47454a499da103da6fc2575a25/passgithelper.py#L394-L429
|
11,268
|
languitar/pass-git-helper
|
passgithelper.py
|
SkippingDataExtractor.configure
|
def configure(self, config):
"""Configure the amount of characters to skip."""
self._prefix_length = config.getint(
'skip{suffix}'.format(suffix=self._option_suffix),
fallback=self._prefix_length)
|
python
|
def configure(self, config):
"""Configure the amount of characters to skip."""
self._prefix_length = config.getint(
'skip{suffix}'.format(suffix=self._option_suffix),
fallback=self._prefix_length)
|
[
"def",
"configure",
"(",
"self",
",",
"config",
")",
":",
"self",
".",
"_prefix_length",
"=",
"config",
".",
"getint",
"(",
"'skip{suffix}'",
".",
"format",
"(",
"suffix",
"=",
"self",
".",
"_option_suffix",
")",
",",
"fallback",
"=",
"self",
".",
"_prefix_length",
")"
] |
Configure the amount of characters to skip.
|
[
"Configure",
"the",
"amount",
"of",
"characters",
"to",
"skip",
"."
] |
f84376d9ed6f7c47454a499da103da6fc2575a25
|
https://github.com/languitar/pass-git-helper/blob/f84376d9ed6f7c47454a499da103da6fc2575a25/passgithelper.py#L194-L198
|
11,269
|
asottile/git-code-debt
|
git_code_debt/write_logic.py
|
insert_metric_changes
|
def insert_metric_changes(db, metrics, metric_mapping, commit):
"""Insert into the metric_changes tables.
:param metrics: `list` of `Metric` objects
:param dict metric_mapping: Maps metric names to ids
:param Commit commit:
"""
values = [
[commit.sha, metric_mapping[metric.name], metric.value]
for metric in metrics
if metric.value != 0
]
db.executemany(
'INSERT INTO metric_changes (sha, metric_id, value) VALUES (?, ?, ?)',
values,
)
|
python
|
def insert_metric_changes(db, metrics, metric_mapping, commit):
"""Insert into the metric_changes tables.
:param metrics: `list` of `Metric` objects
:param dict metric_mapping: Maps metric names to ids
:param Commit commit:
"""
values = [
[commit.sha, metric_mapping[metric.name], metric.value]
for metric in metrics
if metric.value != 0
]
db.executemany(
'INSERT INTO metric_changes (sha, metric_id, value) VALUES (?, ?, ?)',
values,
)
|
[
"def",
"insert_metric_changes",
"(",
"db",
",",
"metrics",
",",
"metric_mapping",
",",
"commit",
")",
":",
"values",
"=",
"[",
"[",
"commit",
".",
"sha",
",",
"metric_mapping",
"[",
"metric",
".",
"name",
"]",
",",
"metric",
".",
"value",
"]",
"for",
"metric",
"in",
"metrics",
"if",
"metric",
".",
"value",
"!=",
"0",
"]",
"db",
".",
"executemany",
"(",
"'INSERT INTO metric_changes (sha, metric_id, value) VALUES (?, ?, ?)'",
",",
"values",
",",
")"
] |
Insert into the metric_changes tables.
:param metrics: `list` of `Metric` objects
:param dict metric_mapping: Maps metric names to ids
:param Commit commit:
|
[
"Insert",
"into",
"the",
"metric_changes",
"tables",
"."
] |
31b41e2510063e9739de7987cdca95eaccaecbd6
|
https://github.com/asottile/git-code-debt/blob/31b41e2510063e9739de7987cdca95eaccaecbd6/git_code_debt/write_logic.py#L18-L33
|
11,270
|
asottile/git-code-debt
|
git_code_debt/repo_parser.py
|
RepoParser.get_commits
|
def get_commits(self, since_sha=None):
"""Returns a list of Commit objects.
Args:
since_sha - (optional) A sha to search from
"""
assert self.tempdir
cmd = ['git', 'log', '--first-parent', '--reverse', COMMIT_FORMAT]
if since_sha:
commits = [self.get_commit(since_sha)]
cmd.append('{}..HEAD'.format(since_sha))
else:
commits = []
cmd.append('HEAD')
output = cmd_output(*cmd, cwd=self.tempdir)
for sha, date in chunk_iter(output.splitlines(), 2):
commits.append(Commit(sha, int(date)))
return commits
|
python
|
def get_commits(self, since_sha=None):
"""Returns a list of Commit objects.
Args:
since_sha - (optional) A sha to search from
"""
assert self.tempdir
cmd = ['git', 'log', '--first-parent', '--reverse', COMMIT_FORMAT]
if since_sha:
commits = [self.get_commit(since_sha)]
cmd.append('{}..HEAD'.format(since_sha))
else:
commits = []
cmd.append('HEAD')
output = cmd_output(*cmd, cwd=self.tempdir)
for sha, date in chunk_iter(output.splitlines(), 2):
commits.append(Commit(sha, int(date)))
return commits
|
[
"def",
"get_commits",
"(",
"self",
",",
"since_sha",
"=",
"None",
")",
":",
"assert",
"self",
".",
"tempdir",
"cmd",
"=",
"[",
"'git'",
",",
"'log'",
",",
"'--first-parent'",
",",
"'--reverse'",
",",
"COMMIT_FORMAT",
"]",
"if",
"since_sha",
":",
"commits",
"=",
"[",
"self",
".",
"get_commit",
"(",
"since_sha",
")",
"]",
"cmd",
".",
"append",
"(",
"'{}..HEAD'",
".",
"format",
"(",
"since_sha",
")",
")",
"else",
":",
"commits",
"=",
"[",
"]",
"cmd",
".",
"append",
"(",
"'HEAD'",
")",
"output",
"=",
"cmd_output",
"(",
"*",
"cmd",
",",
"cwd",
"=",
"self",
".",
"tempdir",
")",
"for",
"sha",
",",
"date",
"in",
"chunk_iter",
"(",
"output",
".",
"splitlines",
"(",
")",
",",
"2",
")",
":",
"commits",
".",
"append",
"(",
"Commit",
"(",
"sha",
",",
"int",
"(",
"date",
")",
")",
")",
"return",
"commits"
] |
Returns a list of Commit objects.
Args:
since_sha - (optional) A sha to search from
|
[
"Returns",
"a",
"list",
"of",
"Commit",
"objects",
"."
] |
31b41e2510063e9739de7987cdca95eaccaecbd6
|
https://github.com/asottile/git-code-debt/blob/31b41e2510063e9739de7987cdca95eaccaecbd6/git_code_debt/repo_parser.py#L49-L70
|
11,271
|
asottile/git-code-debt
|
git_code_debt/util/discovery.py
|
discover
|
def discover(package, cls_match_func):
"""Returns a set of classes in the directory matched by cls_match_func
Args:
path - A Python package
cls_match_func - Function taking a class and returning true if the
class is to be included in the output.
"""
matched_classes = set()
for _, module_name, _ in pkgutil.walk_packages(
package.__path__,
prefix=package.__name__ + '.',
):
module = __import__(module_name, fromlist=[str('__trash')], level=0)
# Check all the classes in that module
for _, imported_class in inspect.getmembers(module, inspect.isclass):
# Don't include things that are only there due to a side-effect of
# importing
if imported_class.__module__ != module.__name__:
continue
if cls_match_func(imported_class):
matched_classes.add(imported_class)
return matched_classes
|
python
|
def discover(package, cls_match_func):
"""Returns a set of classes in the directory matched by cls_match_func
Args:
path - A Python package
cls_match_func - Function taking a class and returning true if the
class is to be included in the output.
"""
matched_classes = set()
for _, module_name, _ in pkgutil.walk_packages(
package.__path__,
prefix=package.__name__ + '.',
):
module = __import__(module_name, fromlist=[str('__trash')], level=0)
# Check all the classes in that module
for _, imported_class in inspect.getmembers(module, inspect.isclass):
# Don't include things that are only there due to a side-effect of
# importing
if imported_class.__module__ != module.__name__:
continue
if cls_match_func(imported_class):
matched_classes.add(imported_class)
return matched_classes
|
[
"def",
"discover",
"(",
"package",
",",
"cls_match_func",
")",
":",
"matched_classes",
"=",
"set",
"(",
")",
"for",
"_",
",",
"module_name",
",",
"_",
"in",
"pkgutil",
".",
"walk_packages",
"(",
"package",
".",
"__path__",
",",
"prefix",
"=",
"package",
".",
"__name__",
"+",
"'.'",
",",
")",
":",
"module",
"=",
"__import__",
"(",
"module_name",
",",
"fromlist",
"=",
"[",
"str",
"(",
"'__trash'",
")",
"]",
",",
"level",
"=",
"0",
")",
"# Check all the classes in that module",
"for",
"_",
",",
"imported_class",
"in",
"inspect",
".",
"getmembers",
"(",
"module",
",",
"inspect",
".",
"isclass",
")",
":",
"# Don't include things that are only there due to a side-effect of",
"# importing",
"if",
"imported_class",
".",
"__module__",
"!=",
"module",
".",
"__name__",
":",
"continue",
"if",
"cls_match_func",
"(",
"imported_class",
")",
":",
"matched_classes",
".",
"add",
"(",
"imported_class",
")",
"return",
"matched_classes"
] |
Returns a set of classes in the directory matched by cls_match_func
Args:
path - A Python package
cls_match_func - Function taking a class and returning true if the
class is to be included in the output.
|
[
"Returns",
"a",
"set",
"of",
"classes",
"in",
"the",
"directory",
"matched",
"by",
"cls_match_func"
] |
31b41e2510063e9739de7987cdca95eaccaecbd6
|
https://github.com/asottile/git-code-debt/blob/31b41e2510063e9739de7987cdca95eaccaecbd6/git_code_debt/util/discovery.py#L8-L34
|
11,272
|
asottile/git-code-debt
|
git_code_debt/util/iter.py
|
chunk_iter
|
def chunk_iter(iterable, n):
"""Yields an iterator in chunks
For example you can do
for a, b in chunk_iter([1, 2, 3, 4, 5, 6], 2):
print('{} {}'.format(a, b))
# Prints
# 1 2
# 3 4
# 5 6
Args:
iterable - Some iterable
n - Chunk size (must be greater than 0)
"""
assert n > 0
iterable = iter(iterable)
chunk = tuple(itertools.islice(iterable, n))
while chunk:
yield chunk
chunk = tuple(itertools.islice(iterable, n))
|
python
|
def chunk_iter(iterable, n):
"""Yields an iterator in chunks
For example you can do
for a, b in chunk_iter([1, 2, 3, 4, 5, 6], 2):
print('{} {}'.format(a, b))
# Prints
# 1 2
# 3 4
# 5 6
Args:
iterable - Some iterable
n - Chunk size (must be greater than 0)
"""
assert n > 0
iterable = iter(iterable)
chunk = tuple(itertools.islice(iterable, n))
while chunk:
yield chunk
chunk = tuple(itertools.islice(iterable, n))
|
[
"def",
"chunk_iter",
"(",
"iterable",
",",
"n",
")",
":",
"assert",
"n",
">",
"0",
"iterable",
"=",
"iter",
"(",
"iterable",
")",
"chunk",
"=",
"tuple",
"(",
"itertools",
".",
"islice",
"(",
"iterable",
",",
"n",
")",
")",
"while",
"chunk",
":",
"yield",
"chunk",
"chunk",
"=",
"tuple",
"(",
"itertools",
".",
"islice",
"(",
"iterable",
",",
"n",
")",
")"
] |
Yields an iterator in chunks
For example you can do
for a, b in chunk_iter([1, 2, 3, 4, 5, 6], 2):
print('{} {}'.format(a, b))
# Prints
# 1 2
# 3 4
# 5 6
Args:
iterable - Some iterable
n - Chunk size (must be greater than 0)
|
[
"Yields",
"an",
"iterator",
"in",
"chunks"
] |
31b41e2510063e9739de7987cdca95eaccaecbd6
|
https://github.com/asottile/git-code-debt/blob/31b41e2510063e9739de7987cdca95eaccaecbd6/git_code_debt/util/iter.py#L7-L30
|
11,273
|
asottile/git-code-debt
|
git_code_debt/discovery.py
|
get_metric_parsers
|
def get_metric_parsers(metric_packages=tuple(), include_defaults=True):
"""Gets all of the metric parsers.
Args:
metric_packages - Defaults to no extra packages. An iterable of
metric containing packages. A metric inherits DiffParserBase
and does not have __metric__ = False
A metric package must be imported using import a.b.c
include_defaults - Whether to include the generic metric parsers
"""
metric_parsers = set()
if include_defaults:
import git_code_debt.metrics
metric_parsers.update(discover(git_code_debt.metrics, is_metric_cls))
for metric_package in metric_packages:
metric_parsers.update(discover(metric_package, is_metric_cls))
return metric_parsers
|
python
|
def get_metric_parsers(metric_packages=tuple(), include_defaults=True):
"""Gets all of the metric parsers.
Args:
metric_packages - Defaults to no extra packages. An iterable of
metric containing packages. A metric inherits DiffParserBase
and does not have __metric__ = False
A metric package must be imported using import a.b.c
include_defaults - Whether to include the generic metric parsers
"""
metric_parsers = set()
if include_defaults:
import git_code_debt.metrics
metric_parsers.update(discover(git_code_debt.metrics, is_metric_cls))
for metric_package in metric_packages:
metric_parsers.update(discover(metric_package, is_metric_cls))
return metric_parsers
|
[
"def",
"get_metric_parsers",
"(",
"metric_packages",
"=",
"tuple",
"(",
")",
",",
"include_defaults",
"=",
"True",
")",
":",
"metric_parsers",
"=",
"set",
"(",
")",
"if",
"include_defaults",
":",
"import",
"git_code_debt",
".",
"metrics",
"metric_parsers",
".",
"update",
"(",
"discover",
"(",
"git_code_debt",
".",
"metrics",
",",
"is_metric_cls",
")",
")",
"for",
"metric_package",
"in",
"metric_packages",
":",
"metric_parsers",
".",
"update",
"(",
"discover",
"(",
"metric_package",
",",
"is_metric_cls",
")",
")",
"return",
"metric_parsers"
] |
Gets all of the metric parsers.
Args:
metric_packages - Defaults to no extra packages. An iterable of
metric containing packages. A metric inherits DiffParserBase
and does not have __metric__ = False
A metric package must be imported using import a.b.c
include_defaults - Whether to include the generic metric parsers
|
[
"Gets",
"all",
"of",
"the",
"metric",
"parsers",
"."
] |
31b41e2510063e9739de7987cdca95eaccaecbd6
|
https://github.com/asottile/git-code-debt/blob/31b41e2510063e9739de7987cdca95eaccaecbd6/git_code_debt/discovery.py#L22-L40
|
11,274
|
hustcc/timeago
|
src/timeago/locales/__init__.py
|
timeago_template
|
def timeago_template(locale, index, ago_in):
'''
simple locale implement
'''
try:
LOCALE = __import__('timeago.locales.' + locale)
LOCALE = locale_module(LOCALE, locale)
except:
locale = setting.DEFAULT_LOCALE
LOCALE = __import__('timeago.locales.' + locale)
LOCALE = locale_module(LOCALE, locale)
if isinstance(LOCALE, list):
return LOCALE[index][ago_in]
else:
return LOCALE(index, ago_in)
|
python
|
def timeago_template(locale, index, ago_in):
'''
simple locale implement
'''
try:
LOCALE = __import__('timeago.locales.' + locale)
LOCALE = locale_module(LOCALE, locale)
except:
locale = setting.DEFAULT_LOCALE
LOCALE = __import__('timeago.locales.' + locale)
LOCALE = locale_module(LOCALE, locale)
if isinstance(LOCALE, list):
return LOCALE[index][ago_in]
else:
return LOCALE(index, ago_in)
|
[
"def",
"timeago_template",
"(",
"locale",
",",
"index",
",",
"ago_in",
")",
":",
"try",
":",
"LOCALE",
"=",
"__import__",
"(",
"'timeago.locales.'",
"+",
"locale",
")",
"LOCALE",
"=",
"locale_module",
"(",
"LOCALE",
",",
"locale",
")",
"except",
":",
"locale",
"=",
"setting",
".",
"DEFAULT_LOCALE",
"LOCALE",
"=",
"__import__",
"(",
"'timeago.locales.'",
"+",
"locale",
")",
"LOCALE",
"=",
"locale_module",
"(",
"LOCALE",
",",
"locale",
")",
"if",
"isinstance",
"(",
"LOCALE",
",",
"list",
")",
":",
"return",
"LOCALE",
"[",
"index",
"]",
"[",
"ago_in",
"]",
"else",
":",
"return",
"LOCALE",
"(",
"index",
",",
"ago_in",
")"
] |
simple locale implement
|
[
"simple",
"locale",
"implement"
] |
819fc6efefeccea2a39e6c1cb2f20b5d2cc9f613
|
https://github.com/hustcc/timeago/blob/819fc6efefeccea2a39e6c1cb2f20b5d2cc9f613/src/timeago/locales/__init__.py#L20-L35
|
11,275
|
hustcc/timeago
|
src/timeago/parser.py
|
parse
|
def parse(input):
'''
parse input to datetime
'''
if isinstance(input, datetime):
return input
if isinstance(input, date):
return date_to_datetime(input)
if isinstance(input, time):
return time_to_datetime(input)
if isinstance(input, (int, float)):
return timestamp_to_datetime(input)
if isinstance(input, (str)):
return string_to_data_time(input)
return None
|
python
|
def parse(input):
'''
parse input to datetime
'''
if isinstance(input, datetime):
return input
if isinstance(input, date):
return date_to_datetime(input)
if isinstance(input, time):
return time_to_datetime(input)
if isinstance(input, (int, float)):
return timestamp_to_datetime(input)
if isinstance(input, (str)):
return string_to_data_time(input)
return None
|
[
"def",
"parse",
"(",
"input",
")",
":",
"if",
"isinstance",
"(",
"input",
",",
"datetime",
")",
":",
"return",
"input",
"if",
"isinstance",
"(",
"input",
",",
"date",
")",
":",
"return",
"date_to_datetime",
"(",
"input",
")",
"if",
"isinstance",
"(",
"input",
",",
"time",
")",
":",
"return",
"time_to_datetime",
"(",
"input",
")",
"if",
"isinstance",
"(",
"input",
",",
"(",
"int",
",",
"float",
")",
")",
":",
"return",
"timestamp_to_datetime",
"(",
"input",
")",
"if",
"isinstance",
"(",
"input",
",",
"(",
"str",
")",
")",
":",
"return",
"string_to_data_time",
"(",
"input",
")",
"return",
"None"
] |
parse input to datetime
|
[
"parse",
"input",
"to",
"datetime"
] |
819fc6efefeccea2a39e6c1cb2f20b5d2cc9f613
|
https://github.com/hustcc/timeago/blob/819fc6efefeccea2a39e6c1cb2f20b5d2cc9f613/src/timeago/parser.py#L16-L30
|
11,276
|
hustcc/timeago
|
src/timeago/__init__.py
|
format
|
def format(date, now=None, locale='en'):
'''
the entry method
'''
if not isinstance(date, timedelta):
if now is None:
now = datetime.now()
date = parser.parse(date)
now = parser.parse(now)
if date is None:
raise ParameterUnvalid('the parameter `date` should be datetime '
'/ timedelta, or datetime formated string.')
if now is None:
raise ParameterUnvalid('the parameter `now` should be datetime, '
'or datetime formated string.')
date = now - date
# the gap sec
diff_seconds = int(total_seconds(date))
# is ago or in
ago_in = 0
if diff_seconds < 0:
ago_in = 1 # date is later then now, is the time in future
diff_seconds *= -1 # chango to positive
tmp = 0
i = 0
while i < SEC_ARRAY_LEN:
tmp = SEC_ARRAY[i]
if diff_seconds >= tmp:
i += 1
diff_seconds /= tmp
else:
break
diff_seconds = int(diff_seconds)
i *= 2
if diff_seconds > (i == 0 and 9 or 1):
i += 1
if locale is None:
locale = DEFAULT_LOCALE
tmp = timeago_template(locale, i, ago_in)
if hasattr(tmp, '__call__'):
tmp = tmp(diff_seconds)
return '%s' in tmp and tmp % diff_seconds or tmp
|
python
|
def format(date, now=None, locale='en'):
'''
the entry method
'''
if not isinstance(date, timedelta):
if now is None:
now = datetime.now()
date = parser.parse(date)
now = parser.parse(now)
if date is None:
raise ParameterUnvalid('the parameter `date` should be datetime '
'/ timedelta, or datetime formated string.')
if now is None:
raise ParameterUnvalid('the parameter `now` should be datetime, '
'or datetime formated string.')
date = now - date
# the gap sec
diff_seconds = int(total_seconds(date))
# is ago or in
ago_in = 0
if diff_seconds < 0:
ago_in = 1 # date is later then now, is the time in future
diff_seconds *= -1 # chango to positive
tmp = 0
i = 0
while i < SEC_ARRAY_LEN:
tmp = SEC_ARRAY[i]
if diff_seconds >= tmp:
i += 1
diff_seconds /= tmp
else:
break
diff_seconds = int(diff_seconds)
i *= 2
if diff_seconds > (i == 0 and 9 or 1):
i += 1
if locale is None:
locale = DEFAULT_LOCALE
tmp = timeago_template(locale, i, ago_in)
if hasattr(tmp, '__call__'):
tmp = tmp(diff_seconds)
return '%s' in tmp and tmp % diff_seconds or tmp
|
[
"def",
"format",
"(",
"date",
",",
"now",
"=",
"None",
",",
"locale",
"=",
"'en'",
")",
":",
"if",
"not",
"isinstance",
"(",
"date",
",",
"timedelta",
")",
":",
"if",
"now",
"is",
"None",
":",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"date",
"=",
"parser",
".",
"parse",
"(",
"date",
")",
"now",
"=",
"parser",
".",
"parse",
"(",
"now",
")",
"if",
"date",
"is",
"None",
":",
"raise",
"ParameterUnvalid",
"(",
"'the parameter `date` should be datetime '",
"'/ timedelta, or datetime formated string.'",
")",
"if",
"now",
"is",
"None",
":",
"raise",
"ParameterUnvalid",
"(",
"'the parameter `now` should be datetime, '",
"'or datetime formated string.'",
")",
"date",
"=",
"now",
"-",
"date",
"# the gap sec",
"diff_seconds",
"=",
"int",
"(",
"total_seconds",
"(",
"date",
")",
")",
"# is ago or in",
"ago_in",
"=",
"0",
"if",
"diff_seconds",
"<",
"0",
":",
"ago_in",
"=",
"1",
"# date is later then now, is the time in future",
"diff_seconds",
"*=",
"-",
"1",
"# chango to positive",
"tmp",
"=",
"0",
"i",
"=",
"0",
"while",
"i",
"<",
"SEC_ARRAY_LEN",
":",
"tmp",
"=",
"SEC_ARRAY",
"[",
"i",
"]",
"if",
"diff_seconds",
">=",
"tmp",
":",
"i",
"+=",
"1",
"diff_seconds",
"/=",
"tmp",
"else",
":",
"break",
"diff_seconds",
"=",
"int",
"(",
"diff_seconds",
")",
"i",
"*=",
"2",
"if",
"diff_seconds",
">",
"(",
"i",
"==",
"0",
"and",
"9",
"or",
"1",
")",
":",
"i",
"+=",
"1",
"if",
"locale",
"is",
"None",
":",
"locale",
"=",
"DEFAULT_LOCALE",
"tmp",
"=",
"timeago_template",
"(",
"locale",
",",
"i",
",",
"ago_in",
")",
"if",
"hasattr",
"(",
"tmp",
",",
"'__call__'",
")",
":",
"tmp",
"=",
"tmp",
"(",
"diff_seconds",
")",
"return",
"'%s'",
"in",
"tmp",
"and",
"tmp",
"%",
"diff_seconds",
"or",
"tmp"
] |
the entry method
|
[
"the",
"entry",
"method"
] |
819fc6efefeccea2a39e6c1cb2f20b5d2cc9f613
|
https://github.com/hustcc/timeago/blob/819fc6efefeccea2a39e6c1cb2f20b5d2cc9f613/src/timeago/__init__.py#L36-L83
|
11,277
|
coldfix/udiskie
|
udiskie/mount.py
|
_is_parent_of
|
def _is_parent_of(parent, child):
"""Check whether the first device is the parent of the second device."""
if child.is_partition:
return child.partition_slave == parent
if child.is_toplevel:
return child.drive == parent and child != parent
return False
|
python
|
def _is_parent_of(parent, child):
"""Check whether the first device is the parent of the second device."""
if child.is_partition:
return child.partition_slave == parent
if child.is_toplevel:
return child.drive == parent and child != parent
return False
|
[
"def",
"_is_parent_of",
"(",
"parent",
",",
"child",
")",
":",
"if",
"child",
".",
"is_partition",
":",
"return",
"child",
".",
"partition_slave",
"==",
"parent",
"if",
"child",
".",
"is_toplevel",
":",
"return",
"child",
".",
"drive",
"==",
"parent",
"and",
"child",
"!=",
"parent",
"return",
"False"
] |
Check whether the first device is the parent of the second device.
|
[
"Check",
"whether",
"the",
"first",
"device",
"is",
"the",
"parent",
"of",
"the",
"second",
"device",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L36-L42
|
11,278
|
coldfix/udiskie
|
udiskie/mount.py
|
prune_empty_node
|
def prune_empty_node(node, seen):
"""
Recursively remove empty branches and return whether this makes the node
itself empty.
The ``seen`` parameter is used to avoid infinite recursion due to cycles
(you never know).
"""
if node.methods:
return False
if id(node) in seen:
return True
seen = seen | {id(node)}
for branch in list(node.branches):
if prune_empty_node(branch, seen):
node.branches.remove(branch)
else:
return False
return True
|
python
|
def prune_empty_node(node, seen):
"""
Recursively remove empty branches and return whether this makes the node
itself empty.
The ``seen`` parameter is used to avoid infinite recursion due to cycles
(you never know).
"""
if node.methods:
return False
if id(node) in seen:
return True
seen = seen | {id(node)}
for branch in list(node.branches):
if prune_empty_node(branch, seen):
node.branches.remove(branch)
else:
return False
return True
|
[
"def",
"prune_empty_node",
"(",
"node",
",",
"seen",
")",
":",
"if",
"node",
".",
"methods",
":",
"return",
"False",
"if",
"id",
"(",
"node",
")",
"in",
"seen",
":",
"return",
"True",
"seen",
"=",
"seen",
"|",
"{",
"id",
"(",
"node",
")",
"}",
"for",
"branch",
"in",
"list",
"(",
"node",
".",
"branches",
")",
":",
"if",
"prune_empty_node",
"(",
"branch",
",",
"seen",
")",
":",
"node",
".",
"branches",
".",
"remove",
"(",
"branch",
")",
"else",
":",
"return",
"False",
"return",
"True"
] |
Recursively remove empty branches and return whether this makes the node
itself empty.
The ``seen`` parameter is used to avoid infinite recursion due to cycles
(you never know).
|
[
"Recursively",
"remove",
"empty",
"branches",
"and",
"return",
"whether",
"this",
"makes",
"the",
"node",
"itself",
"empty",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L844-L862
|
11,279
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.browse
|
async def browse(self, device):
"""
Launch file manager on the mount path of the specified device.
:param device: device object, block device path or mount path
:returns: whether the program was successfully launched.
"""
device = self._find_device(device)
if not device.is_mounted:
self._log.error(_("not browsing {0}: not mounted", device))
return False
if not self._browser:
self._log.error(_("not browsing {0}: no program", device))
return False
self._log.debug(_('opening {0} on {0.mount_paths[0]}', device))
self._browser(device.mount_paths[0])
self._log.info(_('opened {0} on {0.mount_paths[0]}', device))
return True
|
python
|
async def browse(self, device):
"""
Launch file manager on the mount path of the specified device.
:param device: device object, block device path or mount path
:returns: whether the program was successfully launched.
"""
device = self._find_device(device)
if not device.is_mounted:
self._log.error(_("not browsing {0}: not mounted", device))
return False
if not self._browser:
self._log.error(_("not browsing {0}: no program", device))
return False
self._log.debug(_('opening {0} on {0.mount_paths[0]}', device))
self._browser(device.mount_paths[0])
self._log.info(_('opened {0} on {0.mount_paths[0]}', device))
return True
|
[
"async",
"def",
"browse",
"(",
"self",
",",
"device",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"device",
".",
"is_mounted",
":",
"self",
".",
"_log",
".",
"error",
"(",
"_",
"(",
"\"not browsing {0}: not mounted\"",
",",
"device",
")",
")",
"return",
"False",
"if",
"not",
"self",
".",
"_browser",
":",
"self",
".",
"_log",
".",
"error",
"(",
"_",
"(",
"\"not browsing {0}: no program\"",
",",
"device",
")",
")",
"return",
"False",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'opening {0} on {0.mount_paths[0]}'",
",",
"device",
")",
")",
"self",
".",
"_browser",
"(",
"device",
".",
"mount_paths",
"[",
"0",
"]",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'opened {0} on {0.mount_paths[0]}'",
",",
"device",
")",
")",
"return",
"True"
] |
Launch file manager on the mount path of the specified device.
:param device: device object, block device path or mount path
:returns: whether the program was successfully launched.
|
[
"Launch",
"file",
"manager",
"on",
"the",
"mount",
"path",
"of",
"the",
"specified",
"device",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L109-L126
|
11,280
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.terminal
|
async def terminal(self, device):
"""
Launch terminal on the mount path of the specified device.
:param device: device object, block device path or mount path
:returns: whether the program was successfully launched.
"""
device = self._find_device(device)
if not device.is_mounted:
self._log.error(_("not opening terminal {0}: not mounted", device))
return False
if not self._terminal:
self._log.error(_("not opening terminal {0}: no program", device))
return False
self._log.debug(_('opening {0} on {0.mount_paths[0]}', device))
self._terminal(device.mount_paths[0])
self._log.info(_('opened {0} on {0.mount_paths[0]}', device))
return True
|
python
|
async def terminal(self, device):
"""
Launch terminal on the mount path of the specified device.
:param device: device object, block device path or mount path
:returns: whether the program was successfully launched.
"""
device = self._find_device(device)
if not device.is_mounted:
self._log.error(_("not opening terminal {0}: not mounted", device))
return False
if not self._terminal:
self._log.error(_("not opening terminal {0}: no program", device))
return False
self._log.debug(_('opening {0} on {0.mount_paths[0]}', device))
self._terminal(device.mount_paths[0])
self._log.info(_('opened {0} on {0.mount_paths[0]}', device))
return True
|
[
"async",
"def",
"terminal",
"(",
"self",
",",
"device",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"device",
".",
"is_mounted",
":",
"self",
".",
"_log",
".",
"error",
"(",
"_",
"(",
"\"not opening terminal {0}: not mounted\"",
",",
"device",
")",
")",
"return",
"False",
"if",
"not",
"self",
".",
"_terminal",
":",
"self",
".",
"_log",
".",
"error",
"(",
"_",
"(",
"\"not opening terminal {0}: no program\"",
",",
"device",
")",
")",
"return",
"False",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'opening {0} on {0.mount_paths[0]}'",
",",
"device",
")",
")",
"self",
".",
"_terminal",
"(",
"device",
".",
"mount_paths",
"[",
"0",
"]",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'opened {0} on {0.mount_paths[0]}'",
",",
"device",
")",
")",
"return",
"True"
] |
Launch terminal on the mount path of the specified device.
:param device: device object, block device path or mount path
:returns: whether the program was successfully launched.
|
[
"Launch",
"terminal",
"on",
"the",
"mount",
"path",
"of",
"the",
"specified",
"device",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L129-L146
|
11,281
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.mount
|
async def mount(self, device):
"""
Mount the device if not already mounted.
:param device: device object, block device path or mount path
:returns: whether the device is mounted.
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_filesystem:
self._log.warn(_('not mounting {0}: unhandled device', device))
return False
if device.is_mounted:
self._log.info(_('not mounting {0}: already mounted', device))
return True
options = match_config(self._config, device, 'options', None)
kwargs = dict(options=options)
self._log.debug(_('mounting {0} with {1}', device, kwargs))
self._check_device_before_mount(device)
mount_path = await device.mount(**kwargs)
self._log.info(_('mounted {0} on {1}', device, mount_path))
return True
|
python
|
async def mount(self, device):
"""
Mount the device if not already mounted.
:param device: device object, block device path or mount path
:returns: whether the device is mounted.
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_filesystem:
self._log.warn(_('not mounting {0}: unhandled device', device))
return False
if device.is_mounted:
self._log.info(_('not mounting {0}: already mounted', device))
return True
options = match_config(self._config, device, 'options', None)
kwargs = dict(options=options)
self._log.debug(_('mounting {0} with {1}', device, kwargs))
self._check_device_before_mount(device)
mount_path = await device.mount(**kwargs)
self._log.info(_('mounted {0} on {1}', device, mount_path))
return True
|
[
"async",
"def",
"mount",
"(",
"self",
",",
"device",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
"or",
"not",
"device",
".",
"is_filesystem",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not mounting {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"if",
"device",
".",
"is_mounted",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not mounting {0}: already mounted'",
",",
"device",
")",
")",
"return",
"True",
"options",
"=",
"match_config",
"(",
"self",
".",
"_config",
",",
"device",
",",
"'options'",
",",
"None",
")",
"kwargs",
"=",
"dict",
"(",
"options",
"=",
"options",
")",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'mounting {0} with {1}'",
",",
"device",
",",
"kwargs",
")",
")",
"self",
".",
"_check_device_before_mount",
"(",
"device",
")",
"mount_path",
"=",
"await",
"device",
".",
"mount",
"(",
"*",
"*",
"kwargs",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'mounted {0} on {1}'",
",",
"device",
",",
"mount_path",
")",
")",
"return",
"True"
] |
Mount the device if not already mounted.
:param device: device object, block device path or mount path
:returns: whether the device is mounted.
|
[
"Mount",
"the",
"device",
"if",
"not",
"already",
"mounted",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L150-L170
|
11,282
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.unmount
|
async def unmount(self, device):
"""
Unmount a Device if mounted.
:param device: device object, block device path or mount path
:returns: whether the device is unmounted
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_filesystem:
self._log.warn(_('not unmounting {0}: unhandled device', device))
return False
if not device.is_mounted:
self._log.info(_('not unmounting {0}: not mounted', device))
return True
self._log.debug(_('unmounting {0}', device))
await device.unmount()
self._log.info(_('unmounted {0}', device))
return True
|
python
|
async def unmount(self, device):
"""
Unmount a Device if mounted.
:param device: device object, block device path or mount path
:returns: whether the device is unmounted
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_filesystem:
self._log.warn(_('not unmounting {0}: unhandled device', device))
return False
if not device.is_mounted:
self._log.info(_('not unmounting {0}: not mounted', device))
return True
self._log.debug(_('unmounting {0}', device))
await device.unmount()
self._log.info(_('unmounted {0}', device))
return True
|
[
"async",
"def",
"unmount",
"(",
"self",
",",
"device",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
"or",
"not",
"device",
".",
"is_filesystem",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not unmounting {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"if",
"not",
"device",
".",
"is_mounted",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not unmounting {0}: not mounted'",
",",
"device",
")",
")",
"return",
"True",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'unmounting {0}'",
",",
"device",
")",
")",
"await",
"device",
".",
"unmount",
"(",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'unmounted {0}'",
",",
"device",
")",
")",
"return",
"True"
] |
Unmount a Device if mounted.
:param device: device object, block device path or mount path
:returns: whether the device is unmounted
|
[
"Unmount",
"a",
"Device",
"if",
"mounted",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L180-L197
|
11,283
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.unlock
|
async def unlock(self, device):
"""
Unlock the device if not already unlocked.
:param device: device object, block device path or mount path
:returns: whether the device is unlocked
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_crypto:
self._log.warn(_('not unlocking {0}: unhandled device', device))
return False
if device.is_unlocked:
self._log.info(_('not unlocking {0}: already unlocked', device))
return True
if not self._prompt:
self._log.error(_('not unlocking {0}: no password prompt', device))
return False
unlocked = await self._unlock_from_cache(device)
if unlocked:
return True
unlocked = await self._unlock_from_keyfile(device)
if unlocked:
return True
options = dict(allow_keyfile=self.udisks.keyfile_support,
allow_cache=self._cache is not None,
cache_hint=self._cache_hint)
password = await self._prompt(device, options)
# password can be: None, str, or udiskie.prompt.PasswordResult
cache_hint = getattr(password, 'cache_hint', self._cache_hint)
password = getattr(password, 'password', password)
if password is None:
self._log.debug(_('not unlocking {0}: cancelled by user', device))
return False
if isinstance(password, bytes):
self._log.debug(_('unlocking {0} using keyfile', device))
await device.unlock_keyfile(password)
else:
self._log.debug(_('unlocking {0}', device))
await device.unlock(password)
self._update_cache(device, password, cache_hint)
self._log.info(_('unlocked {0}', device))
return True
|
python
|
async def unlock(self, device):
"""
Unlock the device if not already unlocked.
:param device: device object, block device path or mount path
:returns: whether the device is unlocked
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_crypto:
self._log.warn(_('not unlocking {0}: unhandled device', device))
return False
if device.is_unlocked:
self._log.info(_('not unlocking {0}: already unlocked', device))
return True
if not self._prompt:
self._log.error(_('not unlocking {0}: no password prompt', device))
return False
unlocked = await self._unlock_from_cache(device)
if unlocked:
return True
unlocked = await self._unlock_from_keyfile(device)
if unlocked:
return True
options = dict(allow_keyfile=self.udisks.keyfile_support,
allow_cache=self._cache is not None,
cache_hint=self._cache_hint)
password = await self._prompt(device, options)
# password can be: None, str, or udiskie.prompt.PasswordResult
cache_hint = getattr(password, 'cache_hint', self._cache_hint)
password = getattr(password, 'password', password)
if password is None:
self._log.debug(_('not unlocking {0}: cancelled by user', device))
return False
if isinstance(password, bytes):
self._log.debug(_('unlocking {0} using keyfile', device))
await device.unlock_keyfile(password)
else:
self._log.debug(_('unlocking {0}', device))
await device.unlock(password)
self._update_cache(device, password, cache_hint)
self._log.info(_('unlocked {0}', device))
return True
|
[
"async",
"def",
"unlock",
"(",
"self",
",",
"device",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
"or",
"not",
"device",
".",
"is_crypto",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not unlocking {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"if",
"device",
".",
"is_unlocked",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not unlocking {0}: already unlocked'",
",",
"device",
")",
")",
"return",
"True",
"if",
"not",
"self",
".",
"_prompt",
":",
"self",
".",
"_log",
".",
"error",
"(",
"_",
"(",
"'not unlocking {0}: no password prompt'",
",",
"device",
")",
")",
"return",
"False",
"unlocked",
"=",
"await",
"self",
".",
"_unlock_from_cache",
"(",
"device",
")",
"if",
"unlocked",
":",
"return",
"True",
"unlocked",
"=",
"await",
"self",
".",
"_unlock_from_keyfile",
"(",
"device",
")",
"if",
"unlocked",
":",
"return",
"True",
"options",
"=",
"dict",
"(",
"allow_keyfile",
"=",
"self",
".",
"udisks",
".",
"keyfile_support",
",",
"allow_cache",
"=",
"self",
".",
"_cache",
"is",
"not",
"None",
",",
"cache_hint",
"=",
"self",
".",
"_cache_hint",
")",
"password",
"=",
"await",
"self",
".",
"_prompt",
"(",
"device",
",",
"options",
")",
"# password can be: None, str, or udiskie.prompt.PasswordResult",
"cache_hint",
"=",
"getattr",
"(",
"password",
",",
"'cache_hint'",
",",
"self",
".",
"_cache_hint",
")",
"password",
"=",
"getattr",
"(",
"password",
",",
"'password'",
",",
"password",
")",
"if",
"password",
"is",
"None",
":",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'not unlocking {0}: cancelled by user'",
",",
"device",
")",
")",
"return",
"False",
"if",
"isinstance",
"(",
"password",
",",
"bytes",
")",
":",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'unlocking {0} using keyfile'",
",",
"device",
")",
")",
"await",
"device",
".",
"unlock_keyfile",
"(",
"password",
")",
"else",
":",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'unlocking {0}'",
",",
"device",
")",
")",
"await",
"device",
".",
"unlock",
"(",
"password",
")",
"self",
".",
"_update_cache",
"(",
"device",
",",
"password",
",",
"cache_hint",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'unlocked {0}'",
",",
"device",
")",
")",
"return",
"True"
] |
Unlock the device if not already unlocked.
:param device: device object, block device path or mount path
:returns: whether the device is unlocked
|
[
"Unlock",
"the",
"device",
"if",
"not",
"already",
"unlocked",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L201-L242
|
11,284
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.lock
|
async def lock(self, device):
"""
Lock device if unlocked.
:param device: device object, block device path or mount path
:returns: whether the device is locked
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_crypto:
self._log.warn(_('not locking {0}: unhandled device', device))
return False
if not device.is_unlocked:
self._log.info(_('not locking {0}: not unlocked', device))
return True
self._log.debug(_('locking {0}', device))
await device.lock()
self._log.info(_('locked {0}', device))
return True
|
python
|
async def lock(self, device):
"""
Lock device if unlocked.
:param device: device object, block device path or mount path
:returns: whether the device is locked
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_crypto:
self._log.warn(_('not locking {0}: unhandled device', device))
return False
if not device.is_unlocked:
self._log.info(_('not locking {0}: not unlocked', device))
return True
self._log.debug(_('locking {0}', device))
await device.lock()
self._log.info(_('locked {0}', device))
return True
|
[
"async",
"def",
"lock",
"(",
"self",
",",
"device",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
"or",
"not",
"device",
".",
"is_crypto",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not locking {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"if",
"not",
"device",
".",
"is_unlocked",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not locking {0}: not unlocked'",
",",
"device",
")",
")",
"return",
"True",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'locking {0}'",
",",
"device",
")",
")",
"await",
"device",
".",
"lock",
"(",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'locked {0}'",
",",
"device",
")",
")",
"return",
"True"
] |
Lock device if unlocked.
:param device: device object, block device path or mount path
:returns: whether the device is locked
|
[
"Lock",
"device",
"if",
"unlocked",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L299-L316
|
11,285
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.add
|
async def add(self, device, recursive=None):
"""
Mount or unlock the device depending on its type.
:param device: device object, block device path or mount path
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
"""
device, created = await self._find_device_losetup(device)
if created and recursive is False:
return device
if device.is_filesystem:
success = await self.mount(device)
elif device.is_crypto:
success = await self.unlock(device)
if success and recursive:
await self.udisks._sync()
device = self.udisks[device.object_path]
success = await self.add(
device.luks_cleartext_holder,
recursive=True)
elif (recursive
and device.is_partition_table
and self.is_handleable(device)):
tasks = [
self.add(dev, recursive=True)
for dev in self.get_all_handleable()
if dev.is_partition and dev.partition_slave == device
]
results = await gather(*tasks)
success = all(results)
else:
self._log.info(_('not adding {0}: unhandled device', device))
return False
return success
|
python
|
async def add(self, device, recursive=None):
"""
Mount or unlock the device depending on its type.
:param device: device object, block device path or mount path
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
"""
device, created = await self._find_device_losetup(device)
if created and recursive is False:
return device
if device.is_filesystem:
success = await self.mount(device)
elif device.is_crypto:
success = await self.unlock(device)
if success and recursive:
await self.udisks._sync()
device = self.udisks[device.object_path]
success = await self.add(
device.luks_cleartext_holder,
recursive=True)
elif (recursive
and device.is_partition_table
and self.is_handleable(device)):
tasks = [
self.add(dev, recursive=True)
for dev in self.get_all_handleable()
if dev.is_partition and dev.partition_slave == device
]
results = await gather(*tasks)
success = all(results)
else:
self._log.info(_('not adding {0}: unhandled device', device))
return False
return success
|
[
"async",
"def",
"add",
"(",
"self",
",",
"device",
",",
"recursive",
"=",
"None",
")",
":",
"device",
",",
"created",
"=",
"await",
"self",
".",
"_find_device_losetup",
"(",
"device",
")",
"if",
"created",
"and",
"recursive",
"is",
"False",
":",
"return",
"device",
"if",
"device",
".",
"is_filesystem",
":",
"success",
"=",
"await",
"self",
".",
"mount",
"(",
"device",
")",
"elif",
"device",
".",
"is_crypto",
":",
"success",
"=",
"await",
"self",
".",
"unlock",
"(",
"device",
")",
"if",
"success",
"and",
"recursive",
":",
"await",
"self",
".",
"udisks",
".",
"_sync",
"(",
")",
"device",
"=",
"self",
".",
"udisks",
"[",
"device",
".",
"object_path",
"]",
"success",
"=",
"await",
"self",
".",
"add",
"(",
"device",
".",
"luks_cleartext_holder",
",",
"recursive",
"=",
"True",
")",
"elif",
"(",
"recursive",
"and",
"device",
".",
"is_partition_table",
"and",
"self",
".",
"is_handleable",
"(",
"device",
")",
")",
":",
"tasks",
"=",
"[",
"self",
".",
"add",
"(",
"dev",
",",
"recursive",
"=",
"True",
")",
"for",
"dev",
"in",
"self",
".",
"get_all_handleable",
"(",
")",
"if",
"dev",
".",
"is_partition",
"and",
"dev",
".",
"partition_slave",
"==",
"device",
"]",
"results",
"=",
"await",
"gather",
"(",
"*",
"tasks",
")",
"success",
"=",
"all",
"(",
"results",
")",
"else",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not adding {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"return",
"success"
] |
Mount or unlock the device depending on its type.
:param device: device object, block device path or mount path
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
|
[
"Mount",
"or",
"unlock",
"the",
"device",
"depending",
"on",
"its",
"type",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L320-L354
|
11,286
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.auto_add
|
async def auto_add(self, device, recursive=None, automount=True):
"""
Automatically attempt to mount or unlock a device, but be quiet if the
device is not supported.
:param device: device object, block device path or mount path
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
"""
device, created = await self._find_device_losetup(device)
if created and recursive is False:
return device
if device.is_luks_cleartext and self.udisks.version_info >= (2, 7, 0):
await sleep(1.5) # temporary workaround for #153, unreliable
success = True
if not self.is_automount(device, automount):
pass
elif device.is_filesystem:
if not device.is_mounted:
success = await self.mount(device)
elif device.is_crypto:
if self._prompt and not device.is_unlocked:
success = await self.unlock(device)
if success and recursive:
await self.udisks._sync()
device = self.udisks[device.object_path]
success = await self.auto_add(
device.luks_cleartext_holder,
recursive=True)
elif recursive and device.is_partition_table:
tasks = [
self.auto_add(dev, recursive=True)
for dev in self.get_all_handleable()
if dev.is_partition and dev.partition_slave == device
]
results = await gather(*tasks)
success = all(results)
else:
self._log.debug(_('not adding {0}: unhandled device', device))
return success
|
python
|
async def auto_add(self, device, recursive=None, automount=True):
"""
Automatically attempt to mount or unlock a device, but be quiet if the
device is not supported.
:param device: device object, block device path or mount path
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
"""
device, created = await self._find_device_losetup(device)
if created and recursive is False:
return device
if device.is_luks_cleartext and self.udisks.version_info >= (2, 7, 0):
await sleep(1.5) # temporary workaround for #153, unreliable
success = True
if not self.is_automount(device, automount):
pass
elif device.is_filesystem:
if not device.is_mounted:
success = await self.mount(device)
elif device.is_crypto:
if self._prompt and not device.is_unlocked:
success = await self.unlock(device)
if success and recursive:
await self.udisks._sync()
device = self.udisks[device.object_path]
success = await self.auto_add(
device.luks_cleartext_holder,
recursive=True)
elif recursive and device.is_partition_table:
tasks = [
self.auto_add(dev, recursive=True)
for dev in self.get_all_handleable()
if dev.is_partition and dev.partition_slave == device
]
results = await gather(*tasks)
success = all(results)
else:
self._log.debug(_('not adding {0}: unhandled device', device))
return success
|
[
"async",
"def",
"auto_add",
"(",
"self",
",",
"device",
",",
"recursive",
"=",
"None",
",",
"automount",
"=",
"True",
")",
":",
"device",
",",
"created",
"=",
"await",
"self",
".",
"_find_device_losetup",
"(",
"device",
")",
"if",
"created",
"and",
"recursive",
"is",
"False",
":",
"return",
"device",
"if",
"device",
".",
"is_luks_cleartext",
"and",
"self",
".",
"udisks",
".",
"version_info",
">=",
"(",
"2",
",",
"7",
",",
"0",
")",
":",
"await",
"sleep",
"(",
"1.5",
")",
"# temporary workaround for #153, unreliable",
"success",
"=",
"True",
"if",
"not",
"self",
".",
"is_automount",
"(",
"device",
",",
"automount",
")",
":",
"pass",
"elif",
"device",
".",
"is_filesystem",
":",
"if",
"not",
"device",
".",
"is_mounted",
":",
"success",
"=",
"await",
"self",
".",
"mount",
"(",
"device",
")",
"elif",
"device",
".",
"is_crypto",
":",
"if",
"self",
".",
"_prompt",
"and",
"not",
"device",
".",
"is_unlocked",
":",
"success",
"=",
"await",
"self",
".",
"unlock",
"(",
"device",
")",
"if",
"success",
"and",
"recursive",
":",
"await",
"self",
".",
"udisks",
".",
"_sync",
"(",
")",
"device",
"=",
"self",
".",
"udisks",
"[",
"device",
".",
"object_path",
"]",
"success",
"=",
"await",
"self",
".",
"auto_add",
"(",
"device",
".",
"luks_cleartext_holder",
",",
"recursive",
"=",
"True",
")",
"elif",
"recursive",
"and",
"device",
".",
"is_partition_table",
":",
"tasks",
"=",
"[",
"self",
".",
"auto_add",
"(",
"dev",
",",
"recursive",
"=",
"True",
")",
"for",
"dev",
"in",
"self",
".",
"get_all_handleable",
"(",
")",
"if",
"dev",
".",
"is_partition",
"and",
"dev",
".",
"partition_slave",
"==",
"device",
"]",
"results",
"=",
"await",
"gather",
"(",
"*",
"tasks",
")",
"success",
"=",
"all",
"(",
"results",
")",
"else",
":",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'not adding {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"success"
] |
Automatically attempt to mount or unlock a device, but be quiet if the
device is not supported.
:param device: device object, block device path or mount path
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
|
[
"Automatically",
"attempt",
"to",
"mount",
"or",
"unlock",
"a",
"device",
"but",
"be",
"quiet",
"if",
"the",
"device",
"is",
"not",
"supported",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L357-L396
|
11,287
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.remove
|
async def remove(self, device, force=False, detach=False, eject=False,
lock=False):
"""
Unmount or lock the device depending on device type.
:param device: device object, block device path or mount path
:param bool force: recursively remove all child devices
:param bool detach: detach the root drive
:param bool eject: remove media from the root drive
:param bool lock: lock the associated LUKS cleartext slave
:returns: whether all attempted operations succeeded
"""
device = self._find_device(device)
if device.is_filesystem:
if device.is_mounted or not device.is_loop or detach is False:
success = await self.unmount(device)
elif device.is_crypto:
if force and device.is_unlocked:
await self.auto_remove(device.luks_cleartext_holder, force=True)
success = await self.lock(device)
elif (force
and (device.is_partition_table or device.is_drive)
and self.is_handleable(device)):
kw = dict(force=True, detach=detach, eject=eject, lock=lock)
tasks = [
self.auto_remove(child, **kw)
for child in self.get_all_handleable()
if _is_parent_of(device, child)
]
results = await gather(*tasks)
success = all(results)
else:
self._log.info(_('not removing {0}: unhandled device', device))
success = False
# if these operations work, everything is fine, we can return True:
if lock and device.is_luks_cleartext:
device = device.luks_cleartext_slave
if self.is_handleable(device):
success = await self.lock(device)
if eject:
success = await self.eject(device)
if (detach or detach is None) and device.is_loop:
success = await self.delete(device, remove=False)
elif detach:
success = await self.detach(device)
return success
|
python
|
async def remove(self, device, force=False, detach=False, eject=False,
lock=False):
"""
Unmount or lock the device depending on device type.
:param device: device object, block device path or mount path
:param bool force: recursively remove all child devices
:param bool detach: detach the root drive
:param bool eject: remove media from the root drive
:param bool lock: lock the associated LUKS cleartext slave
:returns: whether all attempted operations succeeded
"""
device = self._find_device(device)
if device.is_filesystem:
if device.is_mounted or not device.is_loop or detach is False:
success = await self.unmount(device)
elif device.is_crypto:
if force and device.is_unlocked:
await self.auto_remove(device.luks_cleartext_holder, force=True)
success = await self.lock(device)
elif (force
and (device.is_partition_table or device.is_drive)
and self.is_handleable(device)):
kw = dict(force=True, detach=detach, eject=eject, lock=lock)
tasks = [
self.auto_remove(child, **kw)
for child in self.get_all_handleable()
if _is_parent_of(device, child)
]
results = await gather(*tasks)
success = all(results)
else:
self._log.info(_('not removing {0}: unhandled device', device))
success = False
# if these operations work, everything is fine, we can return True:
if lock and device.is_luks_cleartext:
device = device.luks_cleartext_slave
if self.is_handleable(device):
success = await self.lock(device)
if eject:
success = await self.eject(device)
if (detach or detach is None) and device.is_loop:
success = await self.delete(device, remove=False)
elif detach:
success = await self.detach(device)
return success
|
[
"async",
"def",
"remove",
"(",
"self",
",",
"device",
",",
"force",
"=",
"False",
",",
"detach",
"=",
"False",
",",
"eject",
"=",
"False",
",",
"lock",
"=",
"False",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"device",
".",
"is_filesystem",
":",
"if",
"device",
".",
"is_mounted",
"or",
"not",
"device",
".",
"is_loop",
"or",
"detach",
"is",
"False",
":",
"success",
"=",
"await",
"self",
".",
"unmount",
"(",
"device",
")",
"elif",
"device",
".",
"is_crypto",
":",
"if",
"force",
"and",
"device",
".",
"is_unlocked",
":",
"await",
"self",
".",
"auto_remove",
"(",
"device",
".",
"luks_cleartext_holder",
",",
"force",
"=",
"True",
")",
"success",
"=",
"await",
"self",
".",
"lock",
"(",
"device",
")",
"elif",
"(",
"force",
"and",
"(",
"device",
".",
"is_partition_table",
"or",
"device",
".",
"is_drive",
")",
"and",
"self",
".",
"is_handleable",
"(",
"device",
")",
")",
":",
"kw",
"=",
"dict",
"(",
"force",
"=",
"True",
",",
"detach",
"=",
"detach",
",",
"eject",
"=",
"eject",
",",
"lock",
"=",
"lock",
")",
"tasks",
"=",
"[",
"self",
".",
"auto_remove",
"(",
"child",
",",
"*",
"*",
"kw",
")",
"for",
"child",
"in",
"self",
".",
"get_all_handleable",
"(",
")",
"if",
"_is_parent_of",
"(",
"device",
",",
"child",
")",
"]",
"results",
"=",
"await",
"gather",
"(",
"*",
"tasks",
")",
"success",
"=",
"all",
"(",
"results",
")",
"else",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not removing {0}: unhandled device'",
",",
"device",
")",
")",
"success",
"=",
"False",
"# if these operations work, everything is fine, we can return True:",
"if",
"lock",
"and",
"device",
".",
"is_luks_cleartext",
":",
"device",
"=",
"device",
".",
"luks_cleartext_slave",
"if",
"self",
".",
"is_handleable",
"(",
"device",
")",
":",
"success",
"=",
"await",
"self",
".",
"lock",
"(",
"device",
")",
"if",
"eject",
":",
"success",
"=",
"await",
"self",
".",
"eject",
"(",
"device",
")",
"if",
"(",
"detach",
"or",
"detach",
"is",
"None",
")",
"and",
"device",
".",
"is_loop",
":",
"success",
"=",
"await",
"self",
".",
"delete",
"(",
"device",
",",
"remove",
"=",
"False",
")",
"elif",
"detach",
":",
"success",
"=",
"await",
"self",
".",
"detach",
"(",
"device",
")",
"return",
"success"
] |
Unmount or lock the device depending on device type.
:param device: device object, block device path or mount path
:param bool force: recursively remove all child devices
:param bool detach: detach the root drive
:param bool eject: remove media from the root drive
:param bool lock: lock the associated LUKS cleartext slave
:returns: whether all attempted operations succeeded
|
[
"Unmount",
"or",
"lock",
"the",
"device",
"depending",
"on",
"device",
"type",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L399-L444
|
11,288
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.eject
|
async def eject(self, device, force=False):
"""
Eject a device after unmounting all its mounted filesystems.
:param device: device object, block device path or mount path
:param bool force: remove child devices before trying to eject
:returns: whether the operation succeeded
"""
device = self._find_device(device)
if not self.is_handleable(device):
self._log.warn(_('not ejecting {0}: unhandled device'))
return False
drive = device.drive
if not (drive.is_drive and drive.is_ejectable):
self._log.warn(_('not ejecting {0}: drive not ejectable', drive))
return False
if force:
# Can't autoremove 'device.drive', because that will be filtered
# due to block=False:
await self.auto_remove(device.root, force=True)
self._log.debug(_('ejecting {0}', device))
await drive.eject()
self._log.info(_('ejected {0}', device))
return True
|
python
|
async def eject(self, device, force=False):
"""
Eject a device after unmounting all its mounted filesystems.
:param device: device object, block device path or mount path
:param bool force: remove child devices before trying to eject
:returns: whether the operation succeeded
"""
device = self._find_device(device)
if not self.is_handleable(device):
self._log.warn(_('not ejecting {0}: unhandled device'))
return False
drive = device.drive
if not (drive.is_drive and drive.is_ejectable):
self._log.warn(_('not ejecting {0}: drive not ejectable', drive))
return False
if force:
# Can't autoremove 'device.drive', because that will be filtered
# due to block=False:
await self.auto_remove(device.root, force=True)
self._log.debug(_('ejecting {0}', device))
await drive.eject()
self._log.info(_('ejected {0}', device))
return True
|
[
"async",
"def",
"eject",
"(",
"self",
",",
"device",
",",
"force",
"=",
"False",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not ejecting {0}: unhandled device'",
")",
")",
"return",
"False",
"drive",
"=",
"device",
".",
"drive",
"if",
"not",
"(",
"drive",
".",
"is_drive",
"and",
"drive",
".",
"is_ejectable",
")",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not ejecting {0}: drive not ejectable'",
",",
"drive",
")",
")",
"return",
"False",
"if",
"force",
":",
"# Can't autoremove 'device.drive', because that will be filtered",
"# due to block=False:",
"await",
"self",
".",
"auto_remove",
"(",
"device",
".",
"root",
",",
"force",
"=",
"True",
")",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'ejecting {0}'",
",",
"device",
")",
")",
"await",
"drive",
".",
"eject",
"(",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'ejected {0}'",
",",
"device",
")",
")",
"return",
"True"
] |
Eject a device after unmounting all its mounted filesystems.
:param device: device object, block device path or mount path
:param bool force: remove child devices before trying to eject
:returns: whether the operation succeeded
|
[
"Eject",
"a",
"device",
"after",
"unmounting",
"all",
"its",
"mounted",
"filesystems",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L496-L519
|
11,289
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.detach
|
async def detach(self, device, force=False):
"""
Detach a device after unmounting all its mounted filesystems.
:param device: device object, block device path or mount path
:param bool force: remove child devices before trying to detach
:returns: whether the operation succeeded
"""
device = self._find_device(device)
if not self.is_handleable(device):
self._log.warn(_('not detaching {0}: unhandled device', device))
return False
drive = device.root
if not drive.is_detachable:
self._log.warn(_('not detaching {0}: drive not detachable', drive))
return False
if force:
await self.auto_remove(drive, force=True)
self._log.debug(_('detaching {0}', device))
await drive.detach()
self._log.info(_('detached {0}', device))
return True
|
python
|
async def detach(self, device, force=False):
"""
Detach a device after unmounting all its mounted filesystems.
:param device: device object, block device path or mount path
:param bool force: remove child devices before trying to detach
:returns: whether the operation succeeded
"""
device = self._find_device(device)
if not self.is_handleable(device):
self._log.warn(_('not detaching {0}: unhandled device', device))
return False
drive = device.root
if not drive.is_detachable:
self._log.warn(_('not detaching {0}: drive not detachable', drive))
return False
if force:
await self.auto_remove(drive, force=True)
self._log.debug(_('detaching {0}', device))
await drive.detach()
self._log.info(_('detached {0}', device))
return True
|
[
"async",
"def",
"detach",
"(",
"self",
",",
"device",
",",
"force",
"=",
"False",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not detaching {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"drive",
"=",
"device",
".",
"root",
"if",
"not",
"drive",
".",
"is_detachable",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not detaching {0}: drive not detachable'",
",",
"drive",
")",
")",
"return",
"False",
"if",
"force",
":",
"await",
"self",
".",
"auto_remove",
"(",
"drive",
",",
"force",
"=",
"True",
")",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'detaching {0}'",
",",
"device",
")",
")",
"await",
"drive",
".",
"detach",
"(",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'detached {0}'",
",",
"device",
")",
")",
"return",
"True"
] |
Detach a device after unmounting all its mounted filesystems.
:param device: device object, block device path or mount path
:param bool force: remove child devices before trying to detach
:returns: whether the operation succeeded
|
[
"Detach",
"a",
"device",
"after",
"unmounting",
"all",
"its",
"mounted",
"filesystems",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L522-L543
|
11,290
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.add_all
|
async def add_all(self, recursive=False):
"""
Add all handleable devices that available at start.
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
"""
tasks = [self.auto_add(device, recursive=recursive)
for device in self.get_all_handleable_leaves()]
results = await gather(*tasks)
success = all(results)
return success
|
python
|
async def add_all(self, recursive=False):
"""
Add all handleable devices that available at start.
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
"""
tasks = [self.auto_add(device, recursive=recursive)
for device in self.get_all_handleable_leaves()]
results = await gather(*tasks)
success = all(results)
return success
|
[
"async",
"def",
"add_all",
"(",
"self",
",",
"recursive",
"=",
"False",
")",
":",
"tasks",
"=",
"[",
"self",
".",
"auto_add",
"(",
"device",
",",
"recursive",
"=",
"recursive",
")",
"for",
"device",
"in",
"self",
".",
"get_all_handleable_leaves",
"(",
")",
"]",
"results",
"=",
"await",
"gather",
"(",
"*",
"tasks",
")",
"success",
"=",
"all",
"(",
"results",
")",
"return",
"success"
] |
Add all handleable devices that available at start.
:param bool recursive: recursively mount and unlock child devices
:returns: whether all attempted operations succeeded
|
[
"Add",
"all",
"handleable",
"devices",
"that",
"available",
"at",
"start",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L546-L557
|
11,291
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.remove_all
|
async def remove_all(self, detach=False, eject=False, lock=False):
"""
Remove all filesystems handleable by udiskie.
:param bool detach: detach the root drive
:param bool eject: remove media from the root drive
:param bool lock: lock the associated LUKS cleartext slave
:returns: whether all attempted operations succeeded
"""
kw = dict(force=True, detach=detach, eject=eject, lock=lock)
tasks = [self.auto_remove(device, **kw)
for device in self.get_all_handleable_roots()]
results = await gather(*tasks)
success = all(results)
return success
|
python
|
async def remove_all(self, detach=False, eject=False, lock=False):
"""
Remove all filesystems handleable by udiskie.
:param bool detach: detach the root drive
:param bool eject: remove media from the root drive
:param bool lock: lock the associated LUKS cleartext slave
:returns: whether all attempted operations succeeded
"""
kw = dict(force=True, detach=detach, eject=eject, lock=lock)
tasks = [self.auto_remove(device, **kw)
for device in self.get_all_handleable_roots()]
results = await gather(*tasks)
success = all(results)
return success
|
[
"async",
"def",
"remove_all",
"(",
"self",
",",
"detach",
"=",
"False",
",",
"eject",
"=",
"False",
",",
"lock",
"=",
"False",
")",
":",
"kw",
"=",
"dict",
"(",
"force",
"=",
"True",
",",
"detach",
"=",
"detach",
",",
"eject",
"=",
"eject",
",",
"lock",
"=",
"lock",
")",
"tasks",
"=",
"[",
"self",
".",
"auto_remove",
"(",
"device",
",",
"*",
"*",
"kw",
")",
"for",
"device",
"in",
"self",
".",
"get_all_handleable_roots",
"(",
")",
"]",
"results",
"=",
"await",
"gather",
"(",
"*",
"tasks",
")",
"success",
"=",
"all",
"(",
"results",
")",
"return",
"success"
] |
Remove all filesystems handleable by udiskie.
:param bool detach: detach the root drive
:param bool eject: remove media from the root drive
:param bool lock: lock the associated LUKS cleartext slave
:returns: whether all attempted operations succeeded
|
[
"Remove",
"all",
"filesystems",
"handleable",
"by",
"udiskie",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L559-L573
|
11,292
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.losetup
|
async def losetup(self, image, read_only=True, offset=None, size=None,
no_part_scan=None):
"""
Setup a loop device.
:param str image: path of the image file
:param bool read_only:
:param int offset:
:param int size:
:param bool no_part_scan:
:returns: the device object for the loop device
"""
try:
device = self.udisks.find(image)
except FileNotFoundError:
pass
else:
self._log.info(_('not setting up {0}: already up', device))
return device
if not os.path.isfile(image):
self._log.error(_('not setting up {0}: not a file', image))
return None
self._log.debug(_('setting up {0}', image))
fd = os.open(image, os.O_RDONLY)
device = await self.udisks.loop_setup(fd, {
'offset': offset,
'size': size,
'read-only': read_only,
'no-part-scan': no_part_scan,
})
self._log.info(_('set up {0} as {1}', image,
device.device_presentation))
return device
|
python
|
async def losetup(self, image, read_only=True, offset=None, size=None,
no_part_scan=None):
"""
Setup a loop device.
:param str image: path of the image file
:param bool read_only:
:param int offset:
:param int size:
:param bool no_part_scan:
:returns: the device object for the loop device
"""
try:
device = self.udisks.find(image)
except FileNotFoundError:
pass
else:
self._log.info(_('not setting up {0}: already up', device))
return device
if not os.path.isfile(image):
self._log.error(_('not setting up {0}: not a file', image))
return None
self._log.debug(_('setting up {0}', image))
fd = os.open(image, os.O_RDONLY)
device = await self.udisks.loop_setup(fd, {
'offset': offset,
'size': size,
'read-only': read_only,
'no-part-scan': no_part_scan,
})
self._log.info(_('set up {0} as {1}', image,
device.device_presentation))
return device
|
[
"async",
"def",
"losetup",
"(",
"self",
",",
"image",
",",
"read_only",
"=",
"True",
",",
"offset",
"=",
"None",
",",
"size",
"=",
"None",
",",
"no_part_scan",
"=",
"None",
")",
":",
"try",
":",
"device",
"=",
"self",
".",
"udisks",
".",
"find",
"(",
"image",
")",
"except",
"FileNotFoundError",
":",
"pass",
"else",
":",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'not setting up {0}: already up'",
",",
"device",
")",
")",
"return",
"device",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"image",
")",
":",
"self",
".",
"_log",
".",
"error",
"(",
"_",
"(",
"'not setting up {0}: not a file'",
",",
"image",
")",
")",
"return",
"None",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'setting up {0}'",
",",
"image",
")",
")",
"fd",
"=",
"os",
".",
"open",
"(",
"image",
",",
"os",
".",
"O_RDONLY",
")",
"device",
"=",
"await",
"self",
".",
"udisks",
".",
"loop_setup",
"(",
"fd",
",",
"{",
"'offset'",
":",
"offset",
",",
"'size'",
":",
"size",
",",
"'read-only'",
":",
"read_only",
",",
"'no-part-scan'",
":",
"no_part_scan",
",",
"}",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'set up {0} as {1}'",
",",
"image",
",",
"device",
".",
"device_presentation",
")",
")",
"return",
"device"
] |
Setup a loop device.
:param str image: path of the image file
:param bool read_only:
:param int offset:
:param int size:
:param bool no_part_scan:
:returns: the device object for the loop device
|
[
"Setup",
"a",
"loop",
"device",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L576-L608
|
11,293
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.delete
|
async def delete(self, device, remove=True):
"""
Detach the loop device.
:param device: device object, block device path or mount path
:param bool remove: whether to unmount the partition etc.
:returns: whether the loop device is deleted
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_loop:
self._log.warn(_('not deleting {0}: unhandled device', device))
return False
if remove:
await self.auto_remove(device, force=True)
self._log.debug(_('deleting {0}', device))
await device.delete()
self._log.info(_('deleted {0}', device))
return True
|
python
|
async def delete(self, device, remove=True):
"""
Detach the loop device.
:param device: device object, block device path or mount path
:param bool remove: whether to unmount the partition etc.
:returns: whether the loop device is deleted
"""
device = self._find_device(device)
if not self.is_handleable(device) or not device.is_loop:
self._log.warn(_('not deleting {0}: unhandled device', device))
return False
if remove:
await self.auto_remove(device, force=True)
self._log.debug(_('deleting {0}', device))
await device.delete()
self._log.info(_('deleted {0}', device))
return True
|
[
"async",
"def",
"delete",
"(",
"self",
",",
"device",
",",
"remove",
"=",
"True",
")",
":",
"device",
"=",
"self",
".",
"_find_device",
"(",
"device",
")",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
"or",
"not",
"device",
".",
"is_loop",
":",
"self",
".",
"_log",
".",
"warn",
"(",
"_",
"(",
"'not deleting {0}: unhandled device'",
",",
"device",
")",
")",
"return",
"False",
"if",
"remove",
":",
"await",
"self",
".",
"auto_remove",
"(",
"device",
",",
"force",
"=",
"True",
")",
"self",
".",
"_log",
".",
"debug",
"(",
"_",
"(",
"'deleting {0}'",
",",
"device",
")",
")",
"await",
"device",
".",
"delete",
"(",
")",
"self",
".",
"_log",
".",
"info",
"(",
"_",
"(",
"'deleted {0}'",
",",
"device",
")",
")",
"return",
"True"
] |
Detach the loop device.
:param device: device object, block device path or mount path
:param bool remove: whether to unmount the partition etc.
:returns: whether the loop device is deleted
|
[
"Detach",
"the",
"loop",
"device",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L611-L628
|
11,294
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.is_handleable
|
def is_handleable(self, device):
# TODO: handle pathes in first argument
"""
Check whether this device should be handled by udiskie.
:param device: device object, block device path or mount path
:returns: handleability
Currently this just means that the device is removable and holds a
filesystem or the device is a LUKS encrypted volume.
"""
ignored = self._ignore_device(device)
# propagate handleability of parent devices:
if ignored is None and device is not None:
return self.is_handleable(_get_parent(device))
return not ignored
|
python
|
def is_handleable(self, device):
# TODO: handle pathes in first argument
"""
Check whether this device should be handled by udiskie.
:param device: device object, block device path or mount path
:returns: handleability
Currently this just means that the device is removable and holds a
filesystem or the device is a LUKS encrypted volume.
"""
ignored = self._ignore_device(device)
# propagate handleability of parent devices:
if ignored is None and device is not None:
return self.is_handleable(_get_parent(device))
return not ignored
|
[
"def",
"is_handleable",
"(",
"self",
",",
"device",
")",
":",
"# TODO: handle pathes in first argument",
"ignored",
"=",
"self",
".",
"_ignore_device",
"(",
"device",
")",
"# propagate handleability of parent devices:",
"if",
"ignored",
"is",
"None",
"and",
"device",
"is",
"not",
"None",
":",
"return",
"self",
".",
"is_handleable",
"(",
"_get_parent",
"(",
"device",
")",
")",
"return",
"not",
"ignored"
] |
Check whether this device should be handled by udiskie.
:param device: device object, block device path or mount path
:returns: handleability
Currently this just means that the device is removable and holds a
filesystem or the device is a LUKS encrypted volume.
|
[
"Check",
"whether",
"this",
"device",
"should",
"be",
"handled",
"by",
"udiskie",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L631-L646
|
11,295
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.is_addable
|
def is_addable(self, device, automount=True):
"""Check if device can be added with ``auto_add``."""
if not self.is_automount(device, automount):
return False
if device.is_filesystem:
return not device.is_mounted
if device.is_crypto:
return self._prompt and not device.is_unlocked
if device.is_partition_table:
return any(self.is_addable(dev)
for dev in self.get_all_handleable()
if dev.partition_slave == device)
return False
|
python
|
def is_addable(self, device, automount=True):
"""Check if device can be added with ``auto_add``."""
if not self.is_automount(device, automount):
return False
if device.is_filesystem:
return not device.is_mounted
if device.is_crypto:
return self._prompt and not device.is_unlocked
if device.is_partition_table:
return any(self.is_addable(dev)
for dev in self.get_all_handleable()
if dev.partition_slave == device)
return False
|
[
"def",
"is_addable",
"(",
"self",
",",
"device",
",",
"automount",
"=",
"True",
")",
":",
"if",
"not",
"self",
".",
"is_automount",
"(",
"device",
",",
"automount",
")",
":",
"return",
"False",
"if",
"device",
".",
"is_filesystem",
":",
"return",
"not",
"device",
".",
"is_mounted",
"if",
"device",
".",
"is_crypto",
":",
"return",
"self",
".",
"_prompt",
"and",
"not",
"device",
".",
"is_unlocked",
"if",
"device",
".",
"is_partition_table",
":",
"return",
"any",
"(",
"self",
".",
"is_addable",
"(",
"dev",
")",
"for",
"dev",
"in",
"self",
".",
"get_all_handleable",
"(",
")",
"if",
"dev",
".",
"partition_slave",
"==",
"device",
")",
"return",
"False"
] |
Check if device can be added with ``auto_add``.
|
[
"Check",
"if",
"device",
"can",
"be",
"added",
"with",
"auto_add",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L656-L668
|
11,296
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.is_removable
|
def is_removable(self, device):
"""Check if device can be removed with ``auto_remove``."""
if not self.is_handleable(device):
return False
if device.is_filesystem:
return device.is_mounted
if device.is_crypto:
return device.is_unlocked
if device.is_partition_table or device.is_drive:
return any(self.is_removable(dev)
for dev in self.get_all_handleable()
if _is_parent_of(device, dev))
return False
|
python
|
def is_removable(self, device):
"""Check if device can be removed with ``auto_remove``."""
if not self.is_handleable(device):
return False
if device.is_filesystem:
return device.is_mounted
if device.is_crypto:
return device.is_unlocked
if device.is_partition_table or device.is_drive:
return any(self.is_removable(dev)
for dev in self.get_all_handleable()
if _is_parent_of(device, dev))
return False
|
[
"def",
"is_removable",
"(",
"self",
",",
"device",
")",
":",
"if",
"not",
"self",
".",
"is_handleable",
"(",
"device",
")",
":",
"return",
"False",
"if",
"device",
".",
"is_filesystem",
":",
"return",
"device",
".",
"is_mounted",
"if",
"device",
".",
"is_crypto",
":",
"return",
"device",
".",
"is_unlocked",
"if",
"device",
".",
"is_partition_table",
"or",
"device",
".",
"is_drive",
":",
"return",
"any",
"(",
"self",
".",
"is_removable",
"(",
"dev",
")",
"for",
"dev",
"in",
"self",
".",
"get_all_handleable",
"(",
")",
"if",
"_is_parent_of",
"(",
"device",
",",
"dev",
")",
")",
"return",
"False"
] |
Check if device can be removed with ``auto_remove``.
|
[
"Check",
"if",
"device",
"can",
"be",
"removed",
"with",
"auto_remove",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L670-L682
|
11,297
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.get_all_handleable
|
def get_all_handleable(self):
"""Get list of all known handleable devices."""
nodes = self.get_device_tree()
return [node.device
for node in sorted(nodes.values(), key=DevNode._sort_key)
if not node.ignored and node.device]
|
python
|
def get_all_handleable(self):
"""Get list of all known handleable devices."""
nodes = self.get_device_tree()
return [node.device
for node in sorted(nodes.values(), key=DevNode._sort_key)
if not node.ignored and node.device]
|
[
"def",
"get_all_handleable",
"(",
"self",
")",
":",
"nodes",
"=",
"self",
".",
"get_device_tree",
"(",
")",
"return",
"[",
"node",
".",
"device",
"for",
"node",
"in",
"sorted",
"(",
"nodes",
".",
"values",
"(",
")",
",",
"key",
"=",
"DevNode",
".",
"_sort_key",
")",
"if",
"not",
"node",
".",
"ignored",
"and",
"node",
".",
"device",
"]"
] |
Get list of all known handleable devices.
|
[
"Get",
"list",
"of",
"all",
"known",
"handleable",
"devices",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L684-L689
|
11,298
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.get_all_handleable_roots
|
def get_all_handleable_roots(self):
"""
Get list of all handleable devices, return only those that represent
root nodes within the filtered device tree.
"""
nodes = self.get_device_tree()
return [node.device
for node in sorted(nodes.values(), key=DevNode._sort_key)
if not node.ignored and node.device
and (node.root == '/' or nodes[node.root].ignored)]
|
python
|
def get_all_handleable_roots(self):
"""
Get list of all handleable devices, return only those that represent
root nodes within the filtered device tree.
"""
nodes = self.get_device_tree()
return [node.device
for node in sorted(nodes.values(), key=DevNode._sort_key)
if not node.ignored and node.device
and (node.root == '/' or nodes[node.root].ignored)]
|
[
"def",
"get_all_handleable_roots",
"(",
"self",
")",
":",
"nodes",
"=",
"self",
".",
"get_device_tree",
"(",
")",
"return",
"[",
"node",
".",
"device",
"for",
"node",
"in",
"sorted",
"(",
"nodes",
".",
"values",
"(",
")",
",",
"key",
"=",
"DevNode",
".",
"_sort_key",
")",
"if",
"not",
"node",
".",
"ignored",
"and",
"node",
".",
"device",
"and",
"(",
"node",
".",
"root",
"==",
"'/'",
"or",
"nodes",
"[",
"node",
".",
"root",
"]",
".",
"ignored",
")",
"]"
] |
Get list of all handleable devices, return only those that represent
root nodes within the filtered device tree.
|
[
"Get",
"list",
"of",
"all",
"handleable",
"devices",
"return",
"only",
"those",
"that",
"represent",
"root",
"nodes",
"within",
"the",
"filtered",
"device",
"tree",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L691-L700
|
11,299
|
coldfix/udiskie
|
udiskie/mount.py
|
Mounter.get_all_handleable_leaves
|
def get_all_handleable_leaves(self):
"""
Get list of all handleable devices, return only those that represent
leaf nodes within the filtered device tree.
"""
nodes = self.get_device_tree()
return [node.device
for node in sorted(nodes.values(), key=DevNode._sort_key)
if not node.ignored and node.device
and all(child.ignored for child in node.children)]
|
python
|
def get_all_handleable_leaves(self):
"""
Get list of all handleable devices, return only those that represent
leaf nodes within the filtered device tree.
"""
nodes = self.get_device_tree()
return [node.device
for node in sorted(nodes.values(), key=DevNode._sort_key)
if not node.ignored and node.device
and all(child.ignored for child in node.children)]
|
[
"def",
"get_all_handleable_leaves",
"(",
"self",
")",
":",
"nodes",
"=",
"self",
".",
"get_device_tree",
"(",
")",
"return",
"[",
"node",
".",
"device",
"for",
"node",
"in",
"sorted",
"(",
"nodes",
".",
"values",
"(",
")",
",",
"key",
"=",
"DevNode",
".",
"_sort_key",
")",
"if",
"not",
"node",
".",
"ignored",
"and",
"node",
".",
"device",
"and",
"all",
"(",
"child",
".",
"ignored",
"for",
"child",
"in",
"node",
".",
"children",
")",
"]"
] |
Get list of all handleable devices, return only those that represent
leaf nodes within the filtered device tree.
|
[
"Get",
"list",
"of",
"all",
"handleable",
"devices",
"return",
"only",
"those",
"that",
"represent",
"leaf",
"nodes",
"within",
"the",
"filtered",
"device",
"tree",
"."
] |
804c9d27df6f7361fec3097c432398f2d702f911
|
https://github.com/coldfix/udiskie/blob/804c9d27df6f7361fec3097c432398f2d702f911/udiskie/mount.py#L702-L711
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.