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
partition
stringclasses
1 value
romanz/trezor-agent
libagent/util.py
ExpiringCache.get
def get(self): """Returns existing value, or None if deadline has expired.""" if self.timer() > self.deadline: self.value = None return self.value
python
def get(self): """Returns existing value, or None if deadline has expired.""" if self.timer() > self.deadline: self.value = None return self.value
[ "def", "get", "(", "self", ")", ":", "if", "self", ".", "timer", "(", ")", ">", "self", ".", "deadline", ":", "self", ".", "value", "=", "None", "return", "self", ".", "value" ]
Returns existing value, or None if deadline has expired.
[ "Returns", "existing", "value", "or", "None", "if", "deadline", "has", "expired", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/util.py#L271-L275
train
romanz/trezor-agent
libagent/util.py
ExpiringCache.set
def set(self, value): """Set new value and reset the deadline for expiration.""" self.deadline = self.timer() + self.duration self.value = value
python
def set(self, value): """Set new value and reset the deadline for expiration.""" self.deadline = self.timer() + self.duration self.value = value
[ "def", "set", "(", "self", ",", "value", ")", ":", "self", ".", "deadline", "=", "self", ".", "timer", "(", ")", "+", "self", ".", "duration", "self", ".", "value", "=", "value" ]
Set new value and reset the deadline for expiration.
[ "Set", "new", "value", "and", "reset", "the", "deadline", "for", "expiration", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/util.py#L277-L280
train
romanz/trezor-agent
libagent/gpg/agent.py
sig_encode
def sig_encode(r, s): """Serialize ECDSA signature data into GPG S-expression.""" r = util.assuan_serialize(util.num2bytes(r, 32)) s = util.assuan_serialize(util.num2bytes(s, 32)) return b'(7:sig-val(5:ecdsa(1:r32:' + r + b')(1:s32:' + s + b')))'
python
def sig_encode(r, s): """Serialize ECDSA signature data into GPG S-expression.""" r = util.assuan_serialize(util.num2bytes(r, 32)) s = util.assuan_serialize(util.num2bytes(s, 32)) return b'(7:sig-val(5:ecdsa(1:r32:' + r + b')(1:s32:' + s + b')))'
[ "def", "sig_encode", "(", "r", ",", "s", ")", ":", "r", "=", "util", ".", "assuan_serialize", "(", "util", ".", "num2bytes", "(", "r", ",", "32", ")", ")", "s", "=", "util", ".", "assuan_serialize", "(", "util", ".", "num2bytes", "(", "s", ",", "32", ")", ")", "return", "b'(7:sig-val(5:ecdsa(1:r32:'", "+", "r", "+", "b')(1:s32:'", "+", "s", "+", "b')))'" ]
Serialize ECDSA signature data into GPG S-expression.
[ "Serialize", "ECDSA", "signature", "data", "into", "GPG", "S", "-", "expression", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L24-L28
train
romanz/trezor-agent
libagent/gpg/agent.py
parse_ecdh
def parse_ecdh(line): """Parse ECDH request and return remote public key.""" prefix, line = line.split(b' ', 1) assert prefix == b'D' exp, leftover = keyring.parse(keyring.unescape(line)) log.debug('ECDH s-exp: %r', exp) assert not leftover label, exp = exp assert label == b'enc-val' assert exp[0] == b'ecdh' items = exp[1:] log.debug('ECDH parameters: %r', items) return dict(items)[b'e']
python
def parse_ecdh(line): """Parse ECDH request and return remote public key.""" prefix, line = line.split(b' ', 1) assert prefix == b'D' exp, leftover = keyring.parse(keyring.unescape(line)) log.debug('ECDH s-exp: %r', exp) assert not leftover label, exp = exp assert label == b'enc-val' assert exp[0] == b'ecdh' items = exp[1:] log.debug('ECDH parameters: %r', items) return dict(items)[b'e']
[ "def", "parse_ecdh", "(", "line", ")", ":", "prefix", ",", "line", "=", "line", ".", "split", "(", "b' '", ",", "1", ")", "assert", "prefix", "==", "b'D'", "exp", ",", "leftover", "=", "keyring", ".", "parse", "(", "keyring", ".", "unescape", "(", "line", ")", ")", "log", ".", "debug", "(", "'ECDH s-exp: %r'", ",", "exp", ")", "assert", "not", "leftover", "label", ",", "exp", "=", "exp", "assert", "label", "==", "b'enc-val'", "assert", "exp", "[", "0", "]", "==", "b'ecdh'", "items", "=", "exp", "[", "1", ":", "]", "log", ".", "debug", "(", "'ECDH parameters: %r'", ",", "items", ")", "return", "dict", "(", "items", ")", "[", "b'e'", "]" ]
Parse ECDH request and return remote public key.
[ "Parse", "ECDH", "request", "and", "return", "remote", "public", "key", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L37-L49
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.handle_getinfo
def handle_getinfo(self, conn, args): """Handle some of the GETINFO messages.""" result = None if args[0] == b'version': result = self.version elif args[0] == b's2k_count': # Use highest number of S2K iterations. # https://www.gnupg.org/documentation/manuals/gnupg/OpenPGP-Options.html # https://tools.ietf.org/html/rfc4880#section-3.7.1.3 result = '{}'.format(64 << 20).encode('ascii') else: log.warning('Unknown GETINFO command: %s', args) if result: keyring.sendline(conn, b'D ' + result)
python
def handle_getinfo(self, conn, args): """Handle some of the GETINFO messages.""" result = None if args[0] == b'version': result = self.version elif args[0] == b's2k_count': # Use highest number of S2K iterations. # https://www.gnupg.org/documentation/manuals/gnupg/OpenPGP-Options.html # https://tools.ietf.org/html/rfc4880#section-3.7.1.3 result = '{}'.format(64 << 20).encode('ascii') else: log.warning('Unknown GETINFO command: %s', args) if result: keyring.sendline(conn, b'D ' + result)
[ "def", "handle_getinfo", "(", "self", ",", "conn", ",", "args", ")", ":", "result", "=", "None", "if", "args", "[", "0", "]", "==", "b'version'", ":", "result", "=", "self", ".", "version", "elif", "args", "[", "0", "]", "==", "b's2k_count'", ":", "# Use highest number of S2K iterations.", "# https://www.gnupg.org/documentation/manuals/gnupg/OpenPGP-Options.html", "# https://tools.ietf.org/html/rfc4880#section-3.7.1.3", "result", "=", "'{}'", ".", "format", "(", "64", "<<", "20", ")", ".", "encode", "(", "'ascii'", ")", "else", ":", "log", ".", "warning", "(", "'Unknown GETINFO command: %s'", ",", "args", ")", "if", "result", ":", "keyring", ".", "sendline", "(", "conn", ",", "b'D '", "+", "result", ")" ]
Handle some of the GETINFO messages.
[ "Handle", "some", "of", "the", "GETINFO", "messages", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L129-L143
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.handle_scd
def handle_scd(self, conn, args): """No support for smart-card device protocol.""" reply = { (b'GETINFO', b'version'): self.version, }.get(args) if reply is None: raise AgentError(b'ERR 100696144 No such device <SCD>') keyring.sendline(conn, b'D ' + reply)
python
def handle_scd(self, conn, args): """No support for smart-card device protocol.""" reply = { (b'GETINFO', b'version'): self.version, }.get(args) if reply is None: raise AgentError(b'ERR 100696144 No such device <SCD>') keyring.sendline(conn, b'D ' + reply)
[ "def", "handle_scd", "(", "self", ",", "conn", ",", "args", ")", ":", "reply", "=", "{", "(", "b'GETINFO'", ",", "b'version'", ")", ":", "self", ".", "version", ",", "}", ".", "get", "(", "args", ")", "if", "reply", "is", "None", ":", "raise", "AgentError", "(", "b'ERR 100696144 No such device <SCD>'", ")", "keyring", ".", "sendline", "(", "conn", ",", "b'D '", "+", "reply", ")" ]
No support for smart-card device protocol.
[ "No", "support", "for", "smart", "-", "card", "device", "protocol", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L145-L152
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.get_identity
def get_identity(self, keygrip): """ Returns device.interface.Identity that matches specified keygrip. In case of missing keygrip, KeyError will be raised. """ keygrip_bytes = binascii.unhexlify(keygrip) pubkey_dict, user_ids = decode.load_by_keygrip( pubkey_bytes=self.pubkey_bytes, keygrip=keygrip_bytes) # We assume the first user ID is used to generate TREZOR-based GPG keys. user_id = user_ids[0]['value'].decode('utf-8') curve_name = protocol.get_curve_name_by_oid(pubkey_dict['curve_oid']) ecdh = (pubkey_dict['algo'] == protocol.ECDH_ALGO_ID) identity = client.create_identity(user_id=user_id, curve_name=curve_name) verifying_key = self.client.pubkey(identity=identity, ecdh=ecdh) pubkey = protocol.PublicKey( curve_name=curve_name, created=pubkey_dict['created'], verifying_key=verifying_key, ecdh=ecdh) assert pubkey.key_id() == pubkey_dict['key_id'] assert pubkey.keygrip() == keygrip_bytes return identity
python
def get_identity(self, keygrip): """ Returns device.interface.Identity that matches specified keygrip. In case of missing keygrip, KeyError will be raised. """ keygrip_bytes = binascii.unhexlify(keygrip) pubkey_dict, user_ids = decode.load_by_keygrip( pubkey_bytes=self.pubkey_bytes, keygrip=keygrip_bytes) # We assume the first user ID is used to generate TREZOR-based GPG keys. user_id = user_ids[0]['value'].decode('utf-8') curve_name = protocol.get_curve_name_by_oid(pubkey_dict['curve_oid']) ecdh = (pubkey_dict['algo'] == protocol.ECDH_ALGO_ID) identity = client.create_identity(user_id=user_id, curve_name=curve_name) verifying_key = self.client.pubkey(identity=identity, ecdh=ecdh) pubkey = protocol.PublicKey( curve_name=curve_name, created=pubkey_dict['created'], verifying_key=verifying_key, ecdh=ecdh) assert pubkey.key_id() == pubkey_dict['key_id'] assert pubkey.keygrip() == keygrip_bytes return identity
[ "def", "get_identity", "(", "self", ",", "keygrip", ")", ":", "keygrip_bytes", "=", "binascii", ".", "unhexlify", "(", "keygrip", ")", "pubkey_dict", ",", "user_ids", "=", "decode", ".", "load_by_keygrip", "(", "pubkey_bytes", "=", "self", ".", "pubkey_bytes", ",", "keygrip", "=", "keygrip_bytes", ")", "# We assume the first user ID is used to generate TREZOR-based GPG keys.", "user_id", "=", "user_ids", "[", "0", "]", "[", "'value'", "]", ".", "decode", "(", "'utf-8'", ")", "curve_name", "=", "protocol", ".", "get_curve_name_by_oid", "(", "pubkey_dict", "[", "'curve_oid'", "]", ")", "ecdh", "=", "(", "pubkey_dict", "[", "'algo'", "]", "==", "protocol", ".", "ECDH_ALGO_ID", ")", "identity", "=", "client", ".", "create_identity", "(", "user_id", "=", "user_id", ",", "curve_name", "=", "curve_name", ")", "verifying_key", "=", "self", ".", "client", ".", "pubkey", "(", "identity", "=", "identity", ",", "ecdh", "=", "ecdh", ")", "pubkey", "=", "protocol", ".", "PublicKey", "(", "curve_name", "=", "curve_name", ",", "created", "=", "pubkey_dict", "[", "'created'", "]", ",", "verifying_key", "=", "verifying_key", ",", "ecdh", "=", "ecdh", ")", "assert", "pubkey", ".", "key_id", "(", ")", "==", "pubkey_dict", "[", "'key_id'", "]", "assert", "pubkey", ".", "keygrip", "(", ")", "==", "keygrip_bytes", "return", "identity" ]
Returns device.interface.Identity that matches specified keygrip. In case of missing keygrip, KeyError will be raised.
[ "Returns", "device", ".", "interface", ".", "Identity", "that", "matches", "specified", "keygrip", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L155-L176
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.pksign
def pksign(self, conn): """Sign a message digest using a private EC key.""" log.debug('signing %r digest (algo #%s)', self.digest, self.algo) identity = self.get_identity(keygrip=self.keygrip) r, s = self.client.sign(identity=identity, digest=binascii.unhexlify(self.digest)) result = sig_encode(r, s) log.debug('result: %r', result) keyring.sendline(conn, b'D ' + result)
python
def pksign(self, conn): """Sign a message digest using a private EC key.""" log.debug('signing %r digest (algo #%s)', self.digest, self.algo) identity = self.get_identity(keygrip=self.keygrip) r, s = self.client.sign(identity=identity, digest=binascii.unhexlify(self.digest)) result = sig_encode(r, s) log.debug('result: %r', result) keyring.sendline(conn, b'D ' + result)
[ "def", "pksign", "(", "self", ",", "conn", ")", ":", "log", ".", "debug", "(", "'signing %r digest (algo #%s)'", ",", "self", ".", "digest", ",", "self", ".", "algo", ")", "identity", "=", "self", ".", "get_identity", "(", "keygrip", "=", "self", ".", "keygrip", ")", "r", ",", "s", "=", "self", ".", "client", ".", "sign", "(", "identity", "=", "identity", ",", "digest", "=", "binascii", ".", "unhexlify", "(", "self", ".", "digest", ")", ")", "result", "=", "sig_encode", "(", "r", ",", "s", ")", "log", ".", "debug", "(", "'result: %r'", ",", "result", ")", "keyring", ".", "sendline", "(", "conn", ",", "b'D '", "+", "result", ")" ]
Sign a message digest using a private EC key.
[ "Sign", "a", "message", "digest", "using", "a", "private", "EC", "key", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L178-L186
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.pkdecrypt
def pkdecrypt(self, conn): """Handle decryption using ECDH.""" for msg in [b'S INQUIRE_MAXLEN 4096', b'INQUIRE CIPHERTEXT']: keyring.sendline(conn, msg) line = keyring.recvline(conn) assert keyring.recvline(conn) == b'END' remote_pubkey = parse_ecdh(line) identity = self.get_identity(keygrip=self.keygrip) ec_point = self.client.ecdh(identity=identity, pubkey=remote_pubkey) keyring.sendline(conn, b'D ' + _serialize_point(ec_point))
python
def pkdecrypt(self, conn): """Handle decryption using ECDH.""" for msg in [b'S INQUIRE_MAXLEN 4096', b'INQUIRE CIPHERTEXT']: keyring.sendline(conn, msg) line = keyring.recvline(conn) assert keyring.recvline(conn) == b'END' remote_pubkey = parse_ecdh(line) identity = self.get_identity(keygrip=self.keygrip) ec_point = self.client.ecdh(identity=identity, pubkey=remote_pubkey) keyring.sendline(conn, b'D ' + _serialize_point(ec_point))
[ "def", "pkdecrypt", "(", "self", ",", "conn", ")", ":", "for", "msg", "in", "[", "b'S INQUIRE_MAXLEN 4096'", ",", "b'INQUIRE CIPHERTEXT'", "]", ":", "keyring", ".", "sendline", "(", "conn", ",", "msg", ")", "line", "=", "keyring", ".", "recvline", "(", "conn", ")", "assert", "keyring", ".", "recvline", "(", "conn", ")", "==", "b'END'", "remote_pubkey", "=", "parse_ecdh", "(", "line", ")", "identity", "=", "self", ".", "get_identity", "(", "keygrip", "=", "self", ".", "keygrip", ")", "ec_point", "=", "self", ".", "client", ".", "ecdh", "(", "identity", "=", "identity", ",", "pubkey", "=", "remote_pubkey", ")", "keyring", ".", "sendline", "(", "conn", ",", "b'D '", "+", "_serialize_point", "(", "ec_point", ")", ")" ]
Handle decryption using ECDH.
[ "Handle", "decryption", "using", "ECDH", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L188-L199
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.have_key
def have_key(self, *keygrips): """Check if any keygrip corresponds to a TREZOR-based key.""" for keygrip in keygrips: try: self.get_identity(keygrip=keygrip) break except KeyError as e: log.warning('HAVEKEY(%s) failed: %s', keygrip, e) else: raise AgentError(b'ERR 67108881 No secret key <GPG Agent>')
python
def have_key(self, *keygrips): """Check if any keygrip corresponds to a TREZOR-based key.""" for keygrip in keygrips: try: self.get_identity(keygrip=keygrip) break except KeyError as e: log.warning('HAVEKEY(%s) failed: %s', keygrip, e) else: raise AgentError(b'ERR 67108881 No secret key <GPG Agent>')
[ "def", "have_key", "(", "self", ",", "*", "keygrips", ")", ":", "for", "keygrip", "in", "keygrips", ":", "try", ":", "self", ".", "get_identity", "(", "keygrip", "=", "keygrip", ")", "break", "except", "KeyError", "as", "e", ":", "log", ".", "warning", "(", "'HAVEKEY(%s) failed: %s'", ",", "keygrip", ",", "e", ")", "else", ":", "raise", "AgentError", "(", "b'ERR 67108881 No secret key <GPG Agent>'", ")" ]
Check if any keygrip corresponds to a TREZOR-based key.
[ "Check", "if", "any", "keygrip", "corresponds", "to", "a", "TREZOR", "-", "based", "key", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L201-L210
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.set_hash
def set_hash(self, algo, digest): """Set algorithm ID and hexadecimal digest for next operation.""" self.algo = algo self.digest = digest
python
def set_hash(self, algo, digest): """Set algorithm ID and hexadecimal digest for next operation.""" self.algo = algo self.digest = digest
[ "def", "set_hash", "(", "self", ",", "algo", ",", "digest", ")", ":", "self", ".", "algo", "=", "algo", "self", ".", "digest", "=", "digest" ]
Set algorithm ID and hexadecimal digest for next operation.
[ "Set", "algorithm", "ID", "and", "hexadecimal", "digest", "for", "next", "operation", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L216-L219
train
romanz/trezor-agent
libagent/gpg/agent.py
Handler.handle
def handle(self, conn): """Handle connection from GPG binary using the ASSUAN protocol.""" keyring.sendline(conn, b'OK') for line in keyring.iterlines(conn): parts = line.split(b' ') command = parts[0] args = tuple(parts[1:]) if command == b'BYE': return elif command == b'KILLAGENT': keyring.sendline(conn, b'OK') raise AgentStop() if command not in self.handlers: log.error('unknown request: %r', line) continue handler = self.handlers[command] if handler: try: handler(conn, args) except AgentError as e: msg, = e.args keyring.sendline(conn, msg) continue keyring.sendline(conn, b'OK')
python
def handle(self, conn): """Handle connection from GPG binary using the ASSUAN protocol.""" keyring.sendline(conn, b'OK') for line in keyring.iterlines(conn): parts = line.split(b' ') command = parts[0] args = tuple(parts[1:]) if command == b'BYE': return elif command == b'KILLAGENT': keyring.sendline(conn, b'OK') raise AgentStop() if command not in self.handlers: log.error('unknown request: %r', line) continue handler = self.handlers[command] if handler: try: handler(conn, args) except AgentError as e: msg, = e.args keyring.sendline(conn, msg) continue keyring.sendline(conn, b'OK')
[ "def", "handle", "(", "self", ",", "conn", ")", ":", "keyring", ".", "sendline", "(", "conn", ",", "b'OK'", ")", "for", "line", "in", "keyring", ".", "iterlines", "(", "conn", ")", ":", "parts", "=", "line", ".", "split", "(", "b' '", ")", "command", "=", "parts", "[", "0", "]", "args", "=", "tuple", "(", "parts", "[", "1", ":", "]", ")", "if", "command", "==", "b'BYE'", ":", "return", "elif", "command", "==", "b'KILLAGENT'", ":", "keyring", ".", "sendline", "(", "conn", ",", "b'OK'", ")", "raise", "AgentStop", "(", ")", "if", "command", "not", "in", "self", ".", "handlers", ":", "log", ".", "error", "(", "'unknown request: %r'", ",", "line", ")", "continue", "handler", "=", "self", ".", "handlers", "[", "command", "]", "if", "handler", ":", "try", ":", "handler", "(", "conn", ",", "args", ")", "except", "AgentError", "as", "e", ":", "msg", ",", "=", "e", ".", "args", "keyring", ".", "sendline", "(", "conn", ",", "msg", ")", "continue", "keyring", ".", "sendline", "(", "conn", ",", "b'OK'", ")" ]
Handle connection from GPG binary using the ASSUAN protocol.
[ "Handle", "connection", "from", "GPG", "binary", "using", "the", "ASSUAN", "protocol", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/agent.py#L221-L247
train
romanz/trezor-agent
libagent/device/fake_device.py
FakeDevice.connect
def connect(self): """Return "dummy" connection.""" log.critical('NEVER USE THIS CODE FOR REAL-LIFE USE-CASES!!!') log.critical('ONLY FOR DEBUGGING AND TESTING!!!') # The code below uses HARD-CODED secret key - and should be used ONLY # for GnuPG integration tests (e.g. when no real device is available). # pylint: disable=attribute-defined-outside-init self.secexp = 1 self.sk = ecdsa.SigningKey.from_secret_exponent( secexp=self.secexp, curve=ecdsa.curves.NIST256p, hashfunc=hashlib.sha256) self.vk = self.sk.get_verifying_key() return self
python
def connect(self): """Return "dummy" connection.""" log.critical('NEVER USE THIS CODE FOR REAL-LIFE USE-CASES!!!') log.critical('ONLY FOR DEBUGGING AND TESTING!!!') # The code below uses HARD-CODED secret key - and should be used ONLY # for GnuPG integration tests (e.g. when no real device is available). # pylint: disable=attribute-defined-outside-init self.secexp = 1 self.sk = ecdsa.SigningKey.from_secret_exponent( secexp=self.secexp, curve=ecdsa.curves.NIST256p, hashfunc=hashlib.sha256) self.vk = self.sk.get_verifying_key() return self
[ "def", "connect", "(", "self", ")", ":", "log", ".", "critical", "(", "'NEVER USE THIS CODE FOR REAL-LIFE USE-CASES!!!'", ")", "log", ".", "critical", "(", "'ONLY FOR DEBUGGING AND TESTING!!!'", ")", "# The code below uses HARD-CODED secret key - and should be used ONLY", "# for GnuPG integration tests (e.g. when no real device is available).", "# pylint: disable=attribute-defined-outside-init", "self", ".", "secexp", "=", "1", "self", ".", "sk", "=", "ecdsa", ".", "SigningKey", ".", "from_secret_exponent", "(", "secexp", "=", "self", ".", "secexp", ",", "curve", "=", "ecdsa", ".", "curves", ".", "NIST256p", ",", "hashfunc", "=", "hashlib", ".", "sha256", ")", "self", ".", "vk", "=", "self", ".", "sk", ".", "get_verifying_key", "(", ")", "return", "self" ]
Return "dummy" connection.
[ "Return", "dummy", "connection", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/fake_device.py#L29-L40
train
romanz/trezor-agent
libagent/gpg/client.py
create_identity
def create_identity(user_id, curve_name): """Create GPG identity for hardware device.""" result = interface.Identity(identity_str='gpg://', curve_name=curve_name) result.identity_dict['host'] = user_id return result
python
def create_identity(user_id, curve_name): """Create GPG identity for hardware device.""" result = interface.Identity(identity_str='gpg://', curve_name=curve_name) result.identity_dict['host'] = user_id return result
[ "def", "create_identity", "(", "user_id", ",", "curve_name", ")", ":", "result", "=", "interface", ".", "Identity", "(", "identity_str", "=", "'gpg://'", ",", "curve_name", "=", "curve_name", ")", "result", ".", "identity_dict", "[", "'host'", "]", "=", "user_id", "return", "result" ]
Create GPG identity for hardware device.
[ "Create", "GPG", "identity", "for", "hardware", "device", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/client.py#L11-L15
train
romanz/trezor-agent
libagent/gpg/client.py
Client.pubkey
def pubkey(self, identity, ecdh=False): """Return public key as VerifyingKey object.""" with self.device: pubkey = self.device.pubkey(ecdh=ecdh, identity=identity) return formats.decompress_pubkey( pubkey=pubkey, curve_name=identity.curve_name)
python
def pubkey(self, identity, ecdh=False): """Return public key as VerifyingKey object.""" with self.device: pubkey = self.device.pubkey(ecdh=ecdh, identity=identity) return formats.decompress_pubkey( pubkey=pubkey, curve_name=identity.curve_name)
[ "def", "pubkey", "(", "self", ",", "identity", ",", "ecdh", "=", "False", ")", ":", "with", "self", ".", "device", ":", "pubkey", "=", "self", ".", "device", ".", "pubkey", "(", "ecdh", "=", "ecdh", ",", "identity", "=", "identity", ")", "return", "formats", ".", "decompress_pubkey", "(", "pubkey", "=", "pubkey", ",", "curve_name", "=", "identity", ".", "curve_name", ")" ]
Return public key as VerifyingKey object.
[ "Return", "public", "key", "as", "VerifyingKey", "object", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/client.py#L25-L30
train
romanz/trezor-agent
libagent/gpg/client.py
Client.sign
def sign(self, identity, digest): """Sign the digest and return a serialized signature.""" log.info('please confirm GPG signature on %s for "%s"...', self.device, identity.to_string()) if identity.curve_name == formats.CURVE_NIST256: digest = digest[:32] # sign the first 256 bits log.debug('signing digest: %s', util.hexlify(digest)) with self.device: sig = self.device.sign(blob=digest, identity=identity) return (util.bytes2num(sig[:32]), util.bytes2num(sig[32:]))
python
def sign(self, identity, digest): """Sign the digest and return a serialized signature.""" log.info('please confirm GPG signature on %s for "%s"...', self.device, identity.to_string()) if identity.curve_name == formats.CURVE_NIST256: digest = digest[:32] # sign the first 256 bits log.debug('signing digest: %s', util.hexlify(digest)) with self.device: sig = self.device.sign(blob=digest, identity=identity) return (util.bytes2num(sig[:32]), util.bytes2num(sig[32:]))
[ "def", "sign", "(", "self", ",", "identity", ",", "digest", ")", ":", "log", ".", "info", "(", "'please confirm GPG signature on %s for \"%s\"...'", ",", "self", ".", "device", ",", "identity", ".", "to_string", "(", ")", ")", "if", "identity", ".", "curve_name", "==", "formats", ".", "CURVE_NIST256", ":", "digest", "=", "digest", "[", ":", "32", "]", "# sign the first 256 bits", "log", ".", "debug", "(", "'signing digest: %s'", ",", "util", ".", "hexlify", "(", "digest", ")", ")", "with", "self", ".", "device", ":", "sig", "=", "self", ".", "device", ".", "sign", "(", "blob", "=", "digest", ",", "identity", "=", "identity", ")", "return", "(", "util", ".", "bytes2num", "(", "sig", "[", ":", "32", "]", ")", ",", "util", ".", "bytes2num", "(", "sig", "[", "32", ":", "]", ")", ")" ]
Sign the digest and return a serialized signature.
[ "Sign", "the", "digest", "and", "return", "a", "serialized", "signature", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/client.py#L32-L41
train
romanz/trezor-agent
libagent/gpg/client.py
Client.ecdh
def ecdh(self, identity, pubkey): """Derive shared secret using ECDH from remote public key.""" log.info('please confirm GPG decryption on %s for "%s"...', self.device, identity.to_string()) with self.device: return self.device.ecdh(pubkey=pubkey, identity=identity)
python
def ecdh(self, identity, pubkey): """Derive shared secret using ECDH from remote public key.""" log.info('please confirm GPG decryption on %s for "%s"...', self.device, identity.to_string()) with self.device: return self.device.ecdh(pubkey=pubkey, identity=identity)
[ "def", "ecdh", "(", "self", ",", "identity", ",", "pubkey", ")", ":", "log", ".", "info", "(", "'please confirm GPG decryption on %s for \"%s\"...'", ",", "self", ".", "device", ",", "identity", ".", "to_string", "(", ")", ")", "with", "self", ".", "device", ":", "return", "self", ".", "device", ".", "ecdh", "(", "pubkey", "=", "pubkey", ",", "identity", "=", "identity", ")" ]
Derive shared secret using ECDH from remote public key.
[ "Derive", "shared", "secret", "using", "ECDH", "from", "remote", "public", "key", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/client.py#L43-L48
train
romanz/trezor-agent
libagent/device/trezor.py
Trezor.connect
def connect(self): """Enumerate and connect to the first available interface.""" transport = self._defs.find_device() if not transport: raise interface.NotFoundError('{} not connected'.format(self)) log.debug('using transport: %s', transport) for _ in range(5): # Retry a few times in case of PIN failures connection = self._defs.Client(transport=transport, ui=self.ui, state=self.__class__.cached_state) self._verify_version(connection) try: connection.ping(msg='', pin_protection=True) # unlock PIN return connection except (self._defs.PinException, ValueError) as e: log.error('Invalid PIN: %s, retrying...', e) continue except Exception as e: log.exception('ping failed: %s', e) connection.close() # so the next HID open() will succeed raise
python
def connect(self): """Enumerate and connect to the first available interface.""" transport = self._defs.find_device() if not transport: raise interface.NotFoundError('{} not connected'.format(self)) log.debug('using transport: %s', transport) for _ in range(5): # Retry a few times in case of PIN failures connection = self._defs.Client(transport=transport, ui=self.ui, state=self.__class__.cached_state) self._verify_version(connection) try: connection.ping(msg='', pin_protection=True) # unlock PIN return connection except (self._defs.PinException, ValueError) as e: log.error('Invalid PIN: %s, retrying...', e) continue except Exception as e: log.exception('ping failed: %s', e) connection.close() # so the next HID open() will succeed raise
[ "def", "connect", "(", "self", ")", ":", "transport", "=", "self", ".", "_defs", ".", "find_device", "(", ")", "if", "not", "transport", ":", "raise", "interface", ".", "NotFoundError", "(", "'{} not connected'", ".", "format", "(", "self", ")", ")", "log", ".", "debug", "(", "'using transport: %s'", ",", "transport", ")", "for", "_", "in", "range", "(", "5", ")", ":", "# Retry a few times in case of PIN failures", "connection", "=", "self", ".", "_defs", ".", "Client", "(", "transport", "=", "transport", ",", "ui", "=", "self", ".", "ui", ",", "state", "=", "self", ".", "__class__", ".", "cached_state", ")", "self", ".", "_verify_version", "(", "connection", ")", "try", ":", "connection", ".", "ping", "(", "msg", "=", "''", ",", "pin_protection", "=", "True", ")", "# unlock PIN", "return", "connection", "except", "(", "self", ".", "_defs", ".", "PinException", ",", "ValueError", ")", "as", "e", ":", "log", ".", "error", "(", "'Invalid PIN: %s, retrying...'", ",", "e", ")", "continue", "except", "Exception", "as", "e", ":", "log", ".", "exception", "(", "'ping failed: %s'", ",", "e", ")", "connection", ".", "close", "(", ")", "# so the next HID open() will succeed", "raise" ]
Enumerate and connect to the first available interface.
[ "Enumerate", "and", "connect", "to", "the", "first", "available", "interface", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/trezor.py#L47-L69
train
romanz/trezor-agent
libagent/device/interface.py
string_to_identity
def string_to_identity(identity_str): """Parse string into Identity dictionary.""" m = _identity_regexp.match(identity_str) result = m.groupdict() log.debug('parsed identity: %s', result) return {k: v for k, v in result.items() if v}
python
def string_to_identity(identity_str): """Parse string into Identity dictionary.""" m = _identity_regexp.match(identity_str) result = m.groupdict() log.debug('parsed identity: %s', result) return {k: v for k, v in result.items() if v}
[ "def", "string_to_identity", "(", "identity_str", ")", ":", "m", "=", "_identity_regexp", ".", "match", "(", "identity_str", ")", "result", "=", "m", ".", "groupdict", "(", ")", "log", ".", "debug", "(", "'parsed identity: %s'", ",", "result", ")", "return", "{", "k", ":", "v", "for", "k", ",", "v", "in", "result", ".", "items", "(", ")", "if", "v", "}" ]
Parse string into Identity dictionary.
[ "Parse", "string", "into", "Identity", "dictionary", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/interface.py#L26-L31
train
romanz/trezor-agent
libagent/device/interface.py
identity_to_string
def identity_to_string(identity_dict): """Dump Identity dictionary into its string representation.""" result = [] if identity_dict.get('proto'): result.append(identity_dict['proto'] + '://') if identity_dict.get('user'): result.append(identity_dict['user'] + '@') result.append(identity_dict['host']) if identity_dict.get('port'): result.append(':' + identity_dict['port']) if identity_dict.get('path'): result.append(identity_dict['path']) log.debug('identity parts: %s', result) return ''.join(result)
python
def identity_to_string(identity_dict): """Dump Identity dictionary into its string representation.""" result = [] if identity_dict.get('proto'): result.append(identity_dict['proto'] + '://') if identity_dict.get('user'): result.append(identity_dict['user'] + '@') result.append(identity_dict['host']) if identity_dict.get('port'): result.append(':' + identity_dict['port']) if identity_dict.get('path'): result.append(identity_dict['path']) log.debug('identity parts: %s', result) return ''.join(result)
[ "def", "identity_to_string", "(", "identity_dict", ")", ":", "result", "=", "[", "]", "if", "identity_dict", ".", "get", "(", "'proto'", ")", ":", "result", ".", "append", "(", "identity_dict", "[", "'proto'", "]", "+", "'://'", ")", "if", "identity_dict", ".", "get", "(", "'user'", ")", ":", "result", ".", "append", "(", "identity_dict", "[", "'user'", "]", "+", "'@'", ")", "result", ".", "append", "(", "identity_dict", "[", "'host'", "]", ")", "if", "identity_dict", ".", "get", "(", "'port'", ")", ":", "result", ".", "append", "(", "':'", "+", "identity_dict", "[", "'port'", "]", ")", "if", "identity_dict", ".", "get", "(", "'path'", ")", ":", "result", ".", "append", "(", "identity_dict", "[", "'path'", "]", ")", "log", ".", "debug", "(", "'identity parts: %s'", ",", "result", ")", "return", "''", ".", "join", "(", "result", ")" ]
Dump Identity dictionary into its string representation.
[ "Dump", "Identity", "dictionary", "into", "its", "string", "representation", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/interface.py#L34-L47
train
romanz/trezor-agent
libagent/device/interface.py
Identity.items
def items(self): """Return a copy of identity_dict items.""" return [(k, unidecode.unidecode(v)) for k, v in self.identity_dict.items()]
python
def items(self): """Return a copy of identity_dict items.""" return [(k, unidecode.unidecode(v)) for k, v in self.identity_dict.items()]
[ "def", "items", "(", "self", ")", ":", "return", "[", "(", "k", ",", "unidecode", ".", "unidecode", "(", "v", ")", ")", "for", "k", ",", "v", "in", "self", ".", "identity_dict", ".", "items", "(", ")", "]" ]
Return a copy of identity_dict items.
[ "Return", "a", "copy", "of", "identity_dict", "items", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/interface.py#L70-L73
train
romanz/trezor-agent
libagent/device/interface.py
Identity.to_bytes
def to_bytes(self): """Transliterate Unicode into ASCII.""" s = identity_to_string(self.identity_dict) return unidecode.unidecode(s).encode('ascii')
python
def to_bytes(self): """Transliterate Unicode into ASCII.""" s = identity_to_string(self.identity_dict) return unidecode.unidecode(s).encode('ascii')
[ "def", "to_bytes", "(", "self", ")", ":", "s", "=", "identity_to_string", "(", "self", ".", "identity_dict", ")", "return", "unidecode", ".", "unidecode", "(", "s", ")", ".", "encode", "(", "'ascii'", ")" ]
Transliterate Unicode into ASCII.
[ "Transliterate", "Unicode", "into", "ASCII", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/interface.py#L75-L78
train
romanz/trezor-agent
libagent/device/interface.py
Identity.get_curve_name
def get_curve_name(self, ecdh=False): """Return correct curve name for device operations.""" if ecdh: return formats.get_ecdh_curve_name(self.curve_name) else: return self.curve_name
python
def get_curve_name(self, ecdh=False): """Return correct curve name for device operations.""" if ecdh: return formats.get_ecdh_curve_name(self.curve_name) else: return self.curve_name
[ "def", "get_curve_name", "(", "self", ",", "ecdh", "=", "False", ")", ":", "if", "ecdh", ":", "return", "formats", ".", "get_ecdh_curve_name", "(", "self", ".", "curve_name", ")", "else", ":", "return", "self", ".", "curve_name" ]
Return correct curve name for device operations.
[ "Return", "correct", "curve", "name", "for", "device", "operations", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/interface.py#L97-L102
train
romanz/trezor-agent
libagent/ssh/__init__.py
serve
def serve(handler, sock_path, timeout=UNIX_SOCKET_TIMEOUT): """ Start the ssh-agent server on a UNIX-domain socket. If no connection is made during the specified timeout, retry until the context is over. """ ssh_version = subprocess.check_output(['ssh', '-V'], stderr=subprocess.STDOUT) log.debug('local SSH version: %r', ssh_version) environ = {'SSH_AUTH_SOCK': sock_path, 'SSH_AGENT_PID': str(os.getpid())} device_mutex = threading.Lock() with server.unix_domain_socket_server(sock_path) as sock: sock.settimeout(timeout) quit_event = threading.Event() handle_conn = functools.partial(server.handle_connection, handler=handler, mutex=device_mutex) kwargs = dict(sock=sock, handle_conn=handle_conn, quit_event=quit_event) with server.spawn(server.server_thread, kwargs): try: yield environ finally: log.debug('closing server') quit_event.set()
python
def serve(handler, sock_path, timeout=UNIX_SOCKET_TIMEOUT): """ Start the ssh-agent server on a UNIX-domain socket. If no connection is made during the specified timeout, retry until the context is over. """ ssh_version = subprocess.check_output(['ssh', '-V'], stderr=subprocess.STDOUT) log.debug('local SSH version: %r', ssh_version) environ = {'SSH_AUTH_SOCK': sock_path, 'SSH_AGENT_PID': str(os.getpid())} device_mutex = threading.Lock() with server.unix_domain_socket_server(sock_path) as sock: sock.settimeout(timeout) quit_event = threading.Event() handle_conn = functools.partial(server.handle_connection, handler=handler, mutex=device_mutex) kwargs = dict(sock=sock, handle_conn=handle_conn, quit_event=quit_event) with server.spawn(server.server_thread, kwargs): try: yield environ finally: log.debug('closing server') quit_event.set()
[ "def", "serve", "(", "handler", ",", "sock_path", ",", "timeout", "=", "UNIX_SOCKET_TIMEOUT", ")", ":", "ssh_version", "=", "subprocess", ".", "check_output", "(", "[", "'ssh'", ",", "'-V'", "]", ",", "stderr", "=", "subprocess", ".", "STDOUT", ")", "log", ".", "debug", "(", "'local SSH version: %r'", ",", "ssh_version", ")", "environ", "=", "{", "'SSH_AUTH_SOCK'", ":", "sock_path", ",", "'SSH_AGENT_PID'", ":", "str", "(", "os", ".", "getpid", "(", ")", ")", "}", "device_mutex", "=", "threading", ".", "Lock", "(", ")", "with", "server", ".", "unix_domain_socket_server", "(", "sock_path", ")", "as", "sock", ":", "sock", ".", "settimeout", "(", "timeout", ")", "quit_event", "=", "threading", ".", "Event", "(", ")", "handle_conn", "=", "functools", ".", "partial", "(", "server", ".", "handle_connection", ",", "handler", "=", "handler", ",", "mutex", "=", "device_mutex", ")", "kwargs", "=", "dict", "(", "sock", "=", "sock", ",", "handle_conn", "=", "handle_conn", ",", "quit_event", "=", "quit_event", ")", "with", "server", ".", "spawn", "(", "server", ".", "server_thread", ",", "kwargs", ")", ":", "try", ":", "yield", "environ", "finally", ":", "log", ".", "debug", "(", "'closing server'", ")", "quit_event", ".", "set", "(", ")" ]
Start the ssh-agent server on a UNIX-domain socket. If no connection is made during the specified timeout, retry until the context is over.
[ "Start", "the", "ssh", "-", "agent", "server", "on", "a", "UNIX", "-", "domain", "socket", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L124-L150
train
romanz/trezor-agent
libagent/ssh/__init__.py
run_server
def run_server(conn, command, sock_path, debug, timeout): """Common code for run_agent and run_git below.""" ret = 0 try: handler = protocol.Handler(conn=conn, debug=debug) with serve(handler=handler, sock_path=sock_path, timeout=timeout) as env: if command: ret = server.run_process(command=command, environ=env) else: signal.pause() # wait for signal (e.g. SIGINT) except KeyboardInterrupt: log.info('server stopped') return ret
python
def run_server(conn, command, sock_path, debug, timeout): """Common code for run_agent and run_git below.""" ret = 0 try: handler = protocol.Handler(conn=conn, debug=debug) with serve(handler=handler, sock_path=sock_path, timeout=timeout) as env: if command: ret = server.run_process(command=command, environ=env) else: signal.pause() # wait for signal (e.g. SIGINT) except KeyboardInterrupt: log.info('server stopped') return ret
[ "def", "run_server", "(", "conn", ",", "command", ",", "sock_path", ",", "debug", ",", "timeout", ")", ":", "ret", "=", "0", "try", ":", "handler", "=", "protocol", ".", "Handler", "(", "conn", "=", "conn", ",", "debug", "=", "debug", ")", "with", "serve", "(", "handler", "=", "handler", ",", "sock_path", "=", "sock_path", ",", "timeout", "=", "timeout", ")", "as", "env", ":", "if", "command", ":", "ret", "=", "server", ".", "run_process", "(", "command", "=", "command", ",", "environ", "=", "env", ")", "else", ":", "signal", ".", "pause", "(", ")", "# wait for signal (e.g. SIGINT)", "except", "KeyboardInterrupt", ":", "log", ".", "info", "(", "'server stopped'", ")", "return", "ret" ]
Common code for run_agent and run_git below.
[ "Common", "code", "for", "run_agent", "and", "run_git", "below", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L153-L166
train
romanz/trezor-agent
libagent/ssh/__init__.py
handle_connection_error
def handle_connection_error(func): """Fail with non-zero exit code.""" @functools.wraps(func) def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except device.interface.NotFoundError as e: log.error('Connection error (try unplugging and replugging your device): %s', e) return 1 return wrapper
python
def handle_connection_error(func): """Fail with non-zero exit code.""" @functools.wraps(func) def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except device.interface.NotFoundError as e: log.error('Connection error (try unplugging and replugging your device): %s', e) return 1 return wrapper
[ "def", "handle_connection_error", "(", "func", ")", ":", "@", "functools", ".", "wraps", "(", "func", ")", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "return", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "except", "device", ".", "interface", ".", "NotFoundError", "as", "e", ":", "log", ".", "error", "(", "'Connection error (try unplugging and replugging your device): %s'", ",", "e", ")", "return", "1", "return", "wrapper" ]
Fail with non-zero exit code.
[ "Fail", "with", "non", "-", "zero", "exit", "code", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L169-L178
train
romanz/trezor-agent
libagent/ssh/__init__.py
parse_config
def parse_config(contents): """Parse config file into a list of Identity objects.""" for identity_str, curve_name in re.findall(r'\<(.*?)\|(.*?)\>', contents): yield device.interface.Identity(identity_str=identity_str, curve_name=curve_name)
python
def parse_config(contents): """Parse config file into a list of Identity objects.""" for identity_str, curve_name in re.findall(r'\<(.*?)\|(.*?)\>', contents): yield device.interface.Identity(identity_str=identity_str, curve_name=curve_name)
[ "def", "parse_config", "(", "contents", ")", ":", "for", "identity_str", ",", "curve_name", "in", "re", ".", "findall", "(", "r'\\<(.*?)\\|(.*?)\\>'", ",", "contents", ")", ":", "yield", "device", ".", "interface", ".", "Identity", "(", "identity_str", "=", "identity_str", ",", "curve_name", "=", "curve_name", ")" ]
Parse config file into a list of Identity objects.
[ "Parse", "config", "file", "into", "a", "list", "of", "Identity", "objects", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L181-L185
train
romanz/trezor-agent
libagent/ssh/__init__.py
main
def main(device_type): """Run ssh-agent using given hardware client factory.""" args = create_agent_parser(device_type=device_type).parse_args() util.setup_logging(verbosity=args.verbose, filename=args.log_file) public_keys = None filename = None if args.identity.startswith('/'): filename = args.identity contents = open(filename, 'rb').read().decode('utf-8') # Allow loading previously exported SSH public keys if filename.endswith('.pub'): public_keys = list(import_public_keys(contents)) identities = list(parse_config(contents)) else: identities = [device.interface.Identity( identity_str=args.identity, curve_name=args.ecdsa_curve_name)] for index, identity in enumerate(identities): identity.identity_dict['proto'] = u'ssh' log.info('identity #%d: %s', index, identity.to_string()) # override default PIN/passphrase entry tools (relevant for TREZOR/Keepkey): device_type.ui = device.ui.UI(device_type=device_type, config=vars(args)) device_type.ui.cached_passphrase_ack = util.ExpiringCache( args.cache_expiry_seconds) conn = JustInTimeConnection( conn_factory=lambda: client.Client(device_type()), identities=identities, public_keys=public_keys) sock_path = _get_sock_path(args) command = args.command context = _dummy_context() if args.connect: command = ['ssh'] + ssh_args(conn) + args.command elif args.mosh: command = ['mosh'] + mosh_args(conn) + args.command elif args.daemonize: out = 'SSH_AUTH_SOCK={0}; export SSH_AUTH_SOCK;\n'.format(sock_path) sys.stdout.write(out) sys.stdout.flush() context = daemon.DaemonContext() log.info('running the agent as a daemon on %s', sock_path) elif args.foreground: log.info('running the agent on %s', sock_path) use_shell = bool(args.shell) if use_shell: command = os.environ['SHELL'] sys.stdin.close() if command or args.daemonize or args.foreground: with context: return run_server(conn=conn, command=command, sock_path=sock_path, debug=args.debug, timeout=args.timeout) else: for pk in conn.public_keys(): sys.stdout.write(pk) return 0
python
def main(device_type): """Run ssh-agent using given hardware client factory.""" args = create_agent_parser(device_type=device_type).parse_args() util.setup_logging(verbosity=args.verbose, filename=args.log_file) public_keys = None filename = None if args.identity.startswith('/'): filename = args.identity contents = open(filename, 'rb').read().decode('utf-8') # Allow loading previously exported SSH public keys if filename.endswith('.pub'): public_keys = list(import_public_keys(contents)) identities = list(parse_config(contents)) else: identities = [device.interface.Identity( identity_str=args.identity, curve_name=args.ecdsa_curve_name)] for index, identity in enumerate(identities): identity.identity_dict['proto'] = u'ssh' log.info('identity #%d: %s', index, identity.to_string()) # override default PIN/passphrase entry tools (relevant for TREZOR/Keepkey): device_type.ui = device.ui.UI(device_type=device_type, config=vars(args)) device_type.ui.cached_passphrase_ack = util.ExpiringCache( args.cache_expiry_seconds) conn = JustInTimeConnection( conn_factory=lambda: client.Client(device_type()), identities=identities, public_keys=public_keys) sock_path = _get_sock_path(args) command = args.command context = _dummy_context() if args.connect: command = ['ssh'] + ssh_args(conn) + args.command elif args.mosh: command = ['mosh'] + mosh_args(conn) + args.command elif args.daemonize: out = 'SSH_AUTH_SOCK={0}; export SSH_AUTH_SOCK;\n'.format(sock_path) sys.stdout.write(out) sys.stdout.flush() context = daemon.DaemonContext() log.info('running the agent as a daemon on %s', sock_path) elif args.foreground: log.info('running the agent on %s', sock_path) use_shell = bool(args.shell) if use_shell: command = os.environ['SHELL'] sys.stdin.close() if command or args.daemonize or args.foreground: with context: return run_server(conn=conn, command=command, sock_path=sock_path, debug=args.debug, timeout=args.timeout) else: for pk in conn.public_keys(): sys.stdout.write(pk) return 0
[ "def", "main", "(", "device_type", ")", ":", "args", "=", "create_agent_parser", "(", "device_type", "=", "device_type", ")", ".", "parse_args", "(", ")", "util", ".", "setup_logging", "(", "verbosity", "=", "args", ".", "verbose", ",", "filename", "=", "args", ".", "log_file", ")", "public_keys", "=", "None", "filename", "=", "None", "if", "args", ".", "identity", ".", "startswith", "(", "'/'", ")", ":", "filename", "=", "args", ".", "identity", "contents", "=", "open", "(", "filename", ",", "'rb'", ")", ".", "read", "(", ")", ".", "decode", "(", "'utf-8'", ")", "# Allow loading previously exported SSH public keys", "if", "filename", ".", "endswith", "(", "'.pub'", ")", ":", "public_keys", "=", "list", "(", "import_public_keys", "(", "contents", ")", ")", "identities", "=", "list", "(", "parse_config", "(", "contents", ")", ")", "else", ":", "identities", "=", "[", "device", ".", "interface", ".", "Identity", "(", "identity_str", "=", "args", ".", "identity", ",", "curve_name", "=", "args", ".", "ecdsa_curve_name", ")", "]", "for", "index", ",", "identity", "in", "enumerate", "(", "identities", ")", ":", "identity", ".", "identity_dict", "[", "'proto'", "]", "=", "u'ssh'", "log", ".", "info", "(", "'identity #%d: %s'", ",", "index", ",", "identity", ".", "to_string", "(", ")", ")", "# override default PIN/passphrase entry tools (relevant for TREZOR/Keepkey):", "device_type", ".", "ui", "=", "device", ".", "ui", ".", "UI", "(", "device_type", "=", "device_type", ",", "config", "=", "vars", "(", "args", ")", ")", "device_type", ".", "ui", ".", "cached_passphrase_ack", "=", "util", ".", "ExpiringCache", "(", "args", ".", "cache_expiry_seconds", ")", "conn", "=", "JustInTimeConnection", "(", "conn_factory", "=", "lambda", ":", "client", ".", "Client", "(", "device_type", "(", ")", ")", ",", "identities", "=", "identities", ",", "public_keys", "=", "public_keys", ")", "sock_path", "=", "_get_sock_path", "(", "args", ")", "command", "=", "args", ".", "command", "context", "=", "_dummy_context", "(", ")", "if", "args", ".", "connect", ":", "command", "=", "[", "'ssh'", "]", "+", "ssh_args", "(", "conn", ")", "+", "args", ".", "command", "elif", "args", ".", "mosh", ":", "command", "=", "[", "'mosh'", "]", "+", "mosh_args", "(", "conn", ")", "+", "args", ".", "command", "elif", "args", ".", "daemonize", ":", "out", "=", "'SSH_AUTH_SOCK={0}; export SSH_AUTH_SOCK;\\n'", ".", "format", "(", "sock_path", ")", "sys", ".", "stdout", ".", "write", "(", "out", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "context", "=", "daemon", ".", "DaemonContext", "(", ")", "log", ".", "info", "(", "'running the agent as a daemon on %s'", ",", "sock_path", ")", "elif", "args", ".", "foreground", ":", "log", ".", "info", "(", "'running the agent on %s'", ",", "sock_path", ")", "use_shell", "=", "bool", "(", "args", ".", "shell", ")", "if", "use_shell", ":", "command", "=", "os", ".", "environ", "[", "'SHELL'", "]", "sys", ".", "stdin", ".", "close", "(", ")", "if", "command", "or", "args", ".", "daemonize", "or", "args", ".", "foreground", ":", "with", "context", ":", "return", "run_server", "(", "conn", "=", "conn", ",", "command", "=", "command", ",", "sock_path", "=", "sock_path", ",", "debug", "=", "args", ".", "debug", ",", "timeout", "=", "args", ".", "timeout", ")", "else", ":", "for", "pk", "in", "conn", ".", "public_keys", "(", ")", ":", "sys", ".", "stdout", ".", "write", "(", "pk", ")", "return", "0" ]
Run ssh-agent using given hardware client factory.
[ "Run", "ssh", "-", "agent", "using", "given", "hardware", "client", "factory", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L255-L313
train
romanz/trezor-agent
libagent/ssh/__init__.py
JustInTimeConnection.parse_public_keys
def parse_public_keys(self): """Parse SSH public keys into dictionaries.""" public_keys = [formats.import_public_key(pk) for pk in self.public_keys()] for pk, identity in zip(public_keys, self.identities): pk['identity'] = identity return public_keys
python
def parse_public_keys(self): """Parse SSH public keys into dictionaries.""" public_keys = [formats.import_public_key(pk) for pk in self.public_keys()] for pk, identity in zip(public_keys, self.identities): pk['identity'] = identity return public_keys
[ "def", "parse_public_keys", "(", "self", ")", ":", "public_keys", "=", "[", "formats", ".", "import_public_key", "(", "pk", ")", "for", "pk", "in", "self", ".", "public_keys", "(", ")", "]", "for", "pk", ",", "identity", "in", "zip", "(", "public_keys", ",", "self", ".", "identities", ")", ":", "pk", "[", "'identity'", "]", "=", "identity", "return", "public_keys" ]
Parse SSH public keys into dictionaries.
[ "Parse", "SSH", "public", "keys", "into", "dictionaries", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L213-L219
train
romanz/trezor-agent
libagent/ssh/__init__.py
JustInTimeConnection.public_keys_as_files
def public_keys_as_files(self): """Store public keys as temporary SSH identity files.""" if not self.public_keys_tempfiles: for pk in self.public_keys(): f = tempfile.NamedTemporaryFile(prefix='trezor-ssh-pubkey-', mode='w') f.write(pk) f.flush() self.public_keys_tempfiles.append(f) return self.public_keys_tempfiles
python
def public_keys_as_files(self): """Store public keys as temporary SSH identity files.""" if not self.public_keys_tempfiles: for pk in self.public_keys(): f = tempfile.NamedTemporaryFile(prefix='trezor-ssh-pubkey-', mode='w') f.write(pk) f.flush() self.public_keys_tempfiles.append(f) return self.public_keys_tempfiles
[ "def", "public_keys_as_files", "(", "self", ")", ":", "if", "not", "self", ".", "public_keys_tempfiles", ":", "for", "pk", "in", "self", ".", "public_keys", "(", ")", ":", "f", "=", "tempfile", ".", "NamedTemporaryFile", "(", "prefix", "=", "'trezor-ssh-pubkey-'", ",", "mode", "=", "'w'", ")", "f", ".", "write", "(", "pk", ")", "f", ".", "flush", "(", ")", "self", ".", "public_keys_tempfiles", ".", "append", "(", "f", ")", "return", "self", ".", "public_keys_tempfiles" ]
Store public keys as temporary SSH identity files.
[ "Store", "public", "keys", "as", "temporary", "SSH", "identity", "files", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L221-L230
train
romanz/trezor-agent
libagent/ssh/__init__.py
JustInTimeConnection.sign
def sign(self, blob, identity): """Sign a given blob using the specified identity on the device.""" conn = self.conn_factory() return conn.sign_ssh_challenge(blob=blob, identity=identity)
python
def sign(self, blob, identity): """Sign a given blob using the specified identity on the device.""" conn = self.conn_factory() return conn.sign_ssh_challenge(blob=blob, identity=identity)
[ "def", "sign", "(", "self", ",", "blob", ",", "identity", ")", ":", "conn", "=", "self", ".", "conn_factory", "(", ")", "return", "conn", ".", "sign_ssh_challenge", "(", "blob", "=", "blob", ",", "identity", "=", "identity", ")" ]
Sign a given blob using the specified identity on the device.
[ "Sign", "a", "given", "blob", "using", "the", "specified", "identity", "on", "the", "device", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/ssh/__init__.py#L232-L235
train
romanz/trezor-agent
libagent/gpg/protocol.py
packet
def packet(tag, blob): """Create small GPG packet.""" assert len(blob) < 2**32 if len(blob) < 2**8: length_type = 0 elif len(blob) < 2**16: length_type = 1 else: length_type = 2 fmt = ['>B', '>H', '>L'][length_type] leading_byte = 0x80 | (tag << 2) | (length_type) return struct.pack('>B', leading_byte) + util.prefix_len(fmt, blob)
python
def packet(tag, blob): """Create small GPG packet.""" assert len(blob) < 2**32 if len(blob) < 2**8: length_type = 0 elif len(blob) < 2**16: length_type = 1 else: length_type = 2 fmt = ['>B', '>H', '>L'][length_type] leading_byte = 0x80 | (tag << 2) | (length_type) return struct.pack('>B', leading_byte) + util.prefix_len(fmt, blob)
[ "def", "packet", "(", "tag", ",", "blob", ")", ":", "assert", "len", "(", "blob", ")", "<", "2", "**", "32", "if", "len", "(", "blob", ")", "<", "2", "**", "8", ":", "length_type", "=", "0", "elif", "len", "(", "blob", ")", "<", "2", "**", "16", ":", "length_type", "=", "1", "else", ":", "length_type", "=", "2", "fmt", "=", "[", "'>B'", ",", "'>H'", ",", "'>L'", "]", "[", "length_type", "]", "leading_byte", "=", "0x80", "|", "(", "tag", "<<", "2", ")", "|", "(", "length_type", ")", "return", "struct", ".", "pack", "(", "'>B'", ",", "leading_byte", ")", "+", "util", ".", "prefix_len", "(", "fmt", ",", "blob", ")" ]
Create small GPG packet.
[ "Create", "small", "GPG", "packet", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L13-L26
train
romanz/trezor-agent
libagent/gpg/protocol.py
subpacket
def subpacket(subpacket_type, fmt, *values): """Create GPG subpacket.""" blob = struct.pack(fmt, *values) if values else fmt return struct.pack('>B', subpacket_type) + blob
python
def subpacket(subpacket_type, fmt, *values): """Create GPG subpacket.""" blob = struct.pack(fmt, *values) if values else fmt return struct.pack('>B', subpacket_type) + blob
[ "def", "subpacket", "(", "subpacket_type", ",", "fmt", ",", "*", "values", ")", ":", "blob", "=", "struct", ".", "pack", "(", "fmt", ",", "*", "values", ")", "if", "values", "else", "fmt", "return", "struct", ".", "pack", "(", "'>B'", ",", "subpacket_type", ")", "+", "blob" ]
Create GPG subpacket.
[ "Create", "GPG", "subpacket", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L29-L32
train
romanz/trezor-agent
libagent/gpg/protocol.py
subpacket_prefix_len
def subpacket_prefix_len(item): """Prefix subpacket length according to RFC 4880 section-5.2.3.1.""" n = len(item) if n >= 8384: prefix = b'\xFF' + struct.pack('>L', n) elif n >= 192: n = n - 192 prefix = struct.pack('BB', (n // 256) + 192, n % 256) else: prefix = struct.pack('B', n) return prefix + item
python
def subpacket_prefix_len(item): """Prefix subpacket length according to RFC 4880 section-5.2.3.1.""" n = len(item) if n >= 8384: prefix = b'\xFF' + struct.pack('>L', n) elif n >= 192: n = n - 192 prefix = struct.pack('BB', (n // 256) + 192, n % 256) else: prefix = struct.pack('B', n) return prefix + item
[ "def", "subpacket_prefix_len", "(", "item", ")", ":", "n", "=", "len", "(", "item", ")", "if", "n", ">=", "8384", ":", "prefix", "=", "b'\\xFF'", "+", "struct", ".", "pack", "(", "'>L'", ",", "n", ")", "elif", "n", ">=", "192", ":", "n", "=", "n", "-", "192", "prefix", "=", "struct", ".", "pack", "(", "'BB'", ",", "(", "n", "//", "256", ")", "+", "192", ",", "n", "%", "256", ")", "else", ":", "prefix", "=", "struct", ".", "pack", "(", "'B'", ",", "n", ")", "return", "prefix", "+", "item" ]
Prefix subpacket length according to RFC 4880 section-5.2.3.1.
[ "Prefix", "subpacket", "length", "according", "to", "RFC", "4880", "section", "-", "5", ".", "2", ".", "3", ".", "1", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L55-L65
train
romanz/trezor-agent
libagent/gpg/protocol.py
subpackets
def subpackets(*items): """Serialize several GPG subpackets.""" prefixed = [subpacket_prefix_len(item) for item in items] return util.prefix_len('>H', b''.join(prefixed))
python
def subpackets(*items): """Serialize several GPG subpackets.""" prefixed = [subpacket_prefix_len(item) for item in items] return util.prefix_len('>H', b''.join(prefixed))
[ "def", "subpackets", "(", "*", "items", ")", ":", "prefixed", "=", "[", "subpacket_prefix_len", "(", "item", ")", "for", "item", "in", "items", "]", "return", "util", ".", "prefix_len", "(", "'>H'", ",", "b''", ".", "join", "(", "prefixed", ")", ")" ]
Serialize several GPG subpackets.
[ "Serialize", "several", "GPG", "subpackets", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L68-L71
train
romanz/trezor-agent
libagent/gpg/protocol.py
mpi
def mpi(value): """Serialize multipresicion integer using GPG format.""" bits = value.bit_length() data_size = (bits + 7) // 8 data_bytes = bytearray(data_size) for i in range(data_size): data_bytes[i] = value & 0xFF value = value >> 8 data_bytes.reverse() return struct.pack('>H', bits) + bytes(data_bytes)
python
def mpi(value): """Serialize multipresicion integer using GPG format.""" bits = value.bit_length() data_size = (bits + 7) // 8 data_bytes = bytearray(data_size) for i in range(data_size): data_bytes[i] = value & 0xFF value = value >> 8 data_bytes.reverse() return struct.pack('>H', bits) + bytes(data_bytes)
[ "def", "mpi", "(", "value", ")", ":", "bits", "=", "value", ".", "bit_length", "(", ")", "data_size", "=", "(", "bits", "+", "7", ")", "//", "8", "data_bytes", "=", "bytearray", "(", "data_size", ")", "for", "i", "in", "range", "(", "data_size", ")", ":", "data_bytes", "[", "i", "]", "=", "value", "&", "0xFF", "value", "=", "value", ">>", "8", "data_bytes", ".", "reverse", "(", ")", "return", "struct", ".", "pack", "(", "'>H'", ",", "bits", ")", "+", "bytes", "(", "data_bytes", ")" ]
Serialize multipresicion integer using GPG format.
[ "Serialize", "multipresicion", "integer", "using", "GPG", "format", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L74-L84
train
romanz/trezor-agent
libagent/gpg/protocol.py
keygrip_nist256
def keygrip_nist256(vk): """Compute keygrip for NIST256 curve public keys.""" curve = vk.curve.curve gen = vk.curve.generator g = (4 << 512) | (gen.x() << 256) | gen.y() point = vk.pubkey.point q = (4 << 512) | (point.x() << 256) | point.y() return _compute_keygrip([ ['p', util.num2bytes(curve.p(), size=32)], ['a', util.num2bytes(curve.a() % curve.p(), size=32)], ['b', util.num2bytes(curve.b() % curve.p(), size=32)], ['g', util.num2bytes(g, size=65)], ['n', util.num2bytes(vk.curve.order, size=32)], ['q', util.num2bytes(q, size=65)], ])
python
def keygrip_nist256(vk): """Compute keygrip for NIST256 curve public keys.""" curve = vk.curve.curve gen = vk.curve.generator g = (4 << 512) | (gen.x() << 256) | gen.y() point = vk.pubkey.point q = (4 << 512) | (point.x() << 256) | point.y() return _compute_keygrip([ ['p', util.num2bytes(curve.p(), size=32)], ['a', util.num2bytes(curve.a() % curve.p(), size=32)], ['b', util.num2bytes(curve.b() % curve.p(), size=32)], ['g', util.num2bytes(g, size=65)], ['n', util.num2bytes(vk.curve.order, size=32)], ['q', util.num2bytes(q, size=65)], ])
[ "def", "keygrip_nist256", "(", "vk", ")", ":", "curve", "=", "vk", ".", "curve", ".", "curve", "gen", "=", "vk", ".", "curve", ".", "generator", "g", "=", "(", "4", "<<", "512", ")", "|", "(", "gen", ".", "x", "(", ")", "<<", "256", ")", "|", "gen", ".", "y", "(", ")", "point", "=", "vk", ".", "pubkey", ".", "point", "q", "=", "(", "4", "<<", "512", ")", "|", "(", "point", ".", "x", "(", ")", "<<", "256", ")", "|", "point", ".", "y", "(", ")", "return", "_compute_keygrip", "(", "[", "[", "'p'", ",", "util", ".", "num2bytes", "(", "curve", ".", "p", "(", ")", ",", "size", "=", "32", ")", "]", ",", "[", "'a'", ",", "util", ".", "num2bytes", "(", "curve", ".", "a", "(", ")", "%", "curve", ".", "p", "(", ")", ",", "size", "=", "32", ")", "]", ",", "[", "'b'", ",", "util", ".", "num2bytes", "(", "curve", ".", "b", "(", ")", "%", "curve", ".", "p", "(", ")", ",", "size", "=", "32", ")", "]", ",", "[", "'g'", ",", "util", ".", "num2bytes", "(", "g", ",", "size", "=", "65", ")", "]", ",", "[", "'n'", ",", "util", ".", "num2bytes", "(", "vk", ".", "curve", ".", "order", ",", "size", "=", "32", ")", "]", ",", "[", "'q'", ",", "util", ".", "num2bytes", "(", "q", ",", "size", "=", "65", ")", "]", ",", "]", ")" ]
Compute keygrip for NIST256 curve public keys.
[ "Compute", "keygrip", "for", "NIST256", "curve", "public", "keys", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L107-L122
train
romanz/trezor-agent
libagent/gpg/protocol.py
keygrip_ed25519
def keygrip_ed25519(vk): """Compute keygrip for Ed25519 public keys.""" # pylint: disable=line-too-long return _compute_keygrip([ ['p', util.num2bytes(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED, size=32)], # nopep8 ['a', b'\x01'], ['b', util.num2bytes(0x2DFC9311D490018C7338BF8688861767FF8FF5B2BEBE27548A14B235ECA6874A, size=32)], # nopep8 ['g', util.num2bytes(0x04216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A6666666666666666666666666666666666666666666666666666666666666658, size=65)], # nopep8 ['n', util.num2bytes(0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED, size=32)], # nopep8 ['q', vk.to_bytes()], ])
python
def keygrip_ed25519(vk): """Compute keygrip for Ed25519 public keys.""" # pylint: disable=line-too-long return _compute_keygrip([ ['p', util.num2bytes(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED, size=32)], # nopep8 ['a', b'\x01'], ['b', util.num2bytes(0x2DFC9311D490018C7338BF8688861767FF8FF5B2BEBE27548A14B235ECA6874A, size=32)], # nopep8 ['g', util.num2bytes(0x04216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A6666666666666666666666666666666666666666666666666666666666666658, size=65)], # nopep8 ['n', util.num2bytes(0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED, size=32)], # nopep8 ['q', vk.to_bytes()], ])
[ "def", "keygrip_ed25519", "(", "vk", ")", ":", "# pylint: disable=line-too-long", "return", "_compute_keygrip", "(", "[", "[", "'p'", ",", "util", ".", "num2bytes", "(", "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED", ",", "size", "=", "32", ")", "]", ",", "# nopep8", "[", "'a'", ",", "b'\\x01'", "]", ",", "[", "'b'", ",", "util", ".", "num2bytes", "(", "0x2DFC9311D490018C7338BF8688861767FF8FF5B2BEBE27548A14B235ECA6874A", ",", "size", "=", "32", ")", "]", ",", "# nopep8", "[", "'g'", ",", "util", ".", "num2bytes", "(", "0x04216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A6666666666666666666666666666666666666666666666666666666666666658", ",", "size", "=", "65", ")", "]", ",", "# nopep8", "[", "'n'", ",", "util", ".", "num2bytes", "(", "0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED", ",", "size", "=", "32", ")", "]", ",", "# nopep8", "[", "'q'", ",", "vk", ".", "to_bytes", "(", ")", "]", ",", "]", ")" ]
Compute keygrip for Ed25519 public keys.
[ "Compute", "keygrip", "for", "Ed25519", "public", "keys", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L125-L135
train
romanz/trezor-agent
libagent/gpg/protocol.py
keygrip_curve25519
def keygrip_curve25519(vk): """Compute keygrip for Curve25519 public keys.""" # pylint: disable=line-too-long return _compute_keygrip([ ['p', util.num2bytes(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED, size=32)], # nopep8 ['a', b'\x01\xDB\x41'], ['b', b'\x01'], ['g', util.num2bytes(0x04000000000000000000000000000000000000000000000000000000000000000920ae19a1b8a086b4e01edd2c7748d14c923d4d7e6d7c61b229e9c5a27eced3d9, size=65)], # nopep8 ['n', util.num2bytes(0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED, size=32)], # nopep8 ['q', vk.to_bytes()], ])
python
def keygrip_curve25519(vk): """Compute keygrip for Curve25519 public keys.""" # pylint: disable=line-too-long return _compute_keygrip([ ['p', util.num2bytes(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED, size=32)], # nopep8 ['a', b'\x01\xDB\x41'], ['b', b'\x01'], ['g', util.num2bytes(0x04000000000000000000000000000000000000000000000000000000000000000920ae19a1b8a086b4e01edd2c7748d14c923d4d7e6d7c61b229e9c5a27eced3d9, size=65)], # nopep8 ['n', util.num2bytes(0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED, size=32)], # nopep8 ['q', vk.to_bytes()], ])
[ "def", "keygrip_curve25519", "(", "vk", ")", ":", "# pylint: disable=line-too-long", "return", "_compute_keygrip", "(", "[", "[", "'p'", ",", "util", ".", "num2bytes", "(", "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED", ",", "size", "=", "32", ")", "]", ",", "# nopep8", "[", "'a'", ",", "b'\\x01\\xDB\\x41'", "]", ",", "[", "'b'", ",", "b'\\x01'", "]", ",", "[", "'g'", ",", "util", ".", "num2bytes", "(", "0x04000000000000000000000000000000000000000000000000000000000000000920ae19a1b8a086b4e01edd2c7748d14c923d4d7e6d7c61b229e9c5a27eced3d9", ",", "size", "=", "65", ")", "]", ",", "# nopep8", "[", "'n'", ",", "util", ".", "num2bytes", "(", "0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED", ",", "size", "=", "32", ")", "]", ",", "# nopep8", "[", "'q'", ",", "vk", ".", "to_bytes", "(", ")", "]", ",", "]", ")" ]
Compute keygrip for Curve25519 public keys.
[ "Compute", "keygrip", "for", "Curve25519", "public", "keys", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L138-L148
train
romanz/trezor-agent
libagent/gpg/protocol.py
get_curve_name_by_oid
def get_curve_name_by_oid(oid): """Return curve name matching specified OID, or raise KeyError.""" for curve_name, info in SUPPORTED_CURVES.items(): if info['oid'] == oid: return curve_name raise KeyError('Unknown OID: {!r}'.format(oid))
python
def get_curve_name_by_oid(oid): """Return curve name matching specified OID, or raise KeyError.""" for curve_name, info in SUPPORTED_CURVES.items(): if info['oid'] == oid: return curve_name raise KeyError('Unknown OID: {!r}'.format(oid))
[ "def", "get_curve_name_by_oid", "(", "oid", ")", ":", "for", "curve_name", ",", "info", "in", "SUPPORTED_CURVES", ".", "items", "(", ")", ":", "if", "info", "[", "'oid'", "]", "==", "oid", ":", "return", "curve_name", "raise", "KeyError", "(", "'Unknown OID: {!r}'", ".", "format", "(", "oid", ")", ")" ]
Return curve name matching specified OID, or raise KeyError.
[ "Return", "curve", "name", "matching", "specified", "OID", "or", "raise", "KeyError", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L180-L185
train
romanz/trezor-agent
libagent/gpg/protocol.py
make_signature
def make_signature(signer_func, data_to_sign, public_algo, hashed_subpackets, unhashed_subpackets, sig_type=0): """Create new GPG signature.""" # pylint: disable=too-many-arguments header = struct.pack('>BBBB', 4, # version sig_type, # rfc4880 (section-5.2.1) public_algo, 8) # hash_alg (SHA256) hashed = subpackets(*hashed_subpackets) unhashed = subpackets(*unhashed_subpackets) tail = b'\x04\xff' + struct.pack('>L', len(header) + len(hashed)) data_to_hash = data_to_sign + header + hashed + tail log.debug('hashing %d bytes', len(data_to_hash)) digest = hashlib.sha256(data_to_hash).digest() log.debug('signing digest: %s', util.hexlify(digest)) params = signer_func(digest=digest) sig = b''.join(mpi(p) for p in params) return bytes(header + hashed + unhashed + digest[:2] + # used for decoder's sanity check sig)
python
def make_signature(signer_func, data_to_sign, public_algo, hashed_subpackets, unhashed_subpackets, sig_type=0): """Create new GPG signature.""" # pylint: disable=too-many-arguments header = struct.pack('>BBBB', 4, # version sig_type, # rfc4880 (section-5.2.1) public_algo, 8) # hash_alg (SHA256) hashed = subpackets(*hashed_subpackets) unhashed = subpackets(*unhashed_subpackets) tail = b'\x04\xff' + struct.pack('>L', len(header) + len(hashed)) data_to_hash = data_to_sign + header + hashed + tail log.debug('hashing %d bytes', len(data_to_hash)) digest = hashlib.sha256(data_to_hash).digest() log.debug('signing digest: %s', util.hexlify(digest)) params = signer_func(digest=digest) sig = b''.join(mpi(p) for p in params) return bytes(header + hashed + unhashed + digest[:2] + # used for decoder's sanity check sig)
[ "def", "make_signature", "(", "signer_func", ",", "data_to_sign", ",", "public_algo", ",", "hashed_subpackets", ",", "unhashed_subpackets", ",", "sig_type", "=", "0", ")", ":", "# pylint: disable=too-many-arguments", "header", "=", "struct", ".", "pack", "(", "'>BBBB'", ",", "4", ",", "# version", "sig_type", ",", "# rfc4880 (section-5.2.1)", "public_algo", ",", "8", ")", "# hash_alg (SHA256)", "hashed", "=", "subpackets", "(", "*", "hashed_subpackets", ")", "unhashed", "=", "subpackets", "(", "*", "unhashed_subpackets", ")", "tail", "=", "b'\\x04\\xff'", "+", "struct", ".", "pack", "(", "'>L'", ",", "len", "(", "header", ")", "+", "len", "(", "hashed", ")", ")", "data_to_hash", "=", "data_to_sign", "+", "header", "+", "hashed", "+", "tail", "log", ".", "debug", "(", "'hashing %d bytes'", ",", "len", "(", "data_to_hash", ")", ")", "digest", "=", "hashlib", ".", "sha256", "(", "data_to_hash", ")", ".", "digest", "(", ")", "log", ".", "debug", "(", "'signing digest: %s'", ",", "util", ".", "hexlify", "(", "digest", ")", ")", "params", "=", "signer_func", "(", "digest", "=", "digest", ")", "sig", "=", "b''", ".", "join", "(", "mpi", "(", "p", ")", "for", "p", "in", "params", ")", "return", "bytes", "(", "header", "+", "hashed", "+", "unhashed", "+", "digest", "[", ":", "2", "]", "+", "# used for decoder's sanity check", "sig", ")" ]
Create new GPG signature.
[ "Create", "new", "GPG", "signature", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L254-L276
train
romanz/trezor-agent
libagent/gpg/protocol.py
PublicKey.data
def data(self): """Data for packet creation.""" header = struct.pack('>BLB', 4, # version self.created, # creation self.algo_id) # public key algorithm ID oid = util.prefix_len('>B', self.curve_info['oid']) blob = self.curve_info['serialize'](self.verifying_key) return header + oid + blob + self.ecdh_packet
python
def data(self): """Data for packet creation.""" header = struct.pack('>BLB', 4, # version self.created, # creation self.algo_id) # public key algorithm ID oid = util.prefix_len('>B', self.curve_info['oid']) blob = self.curve_info['serialize'](self.verifying_key) return header + oid + blob + self.ecdh_packet
[ "def", "data", "(", "self", ")", ":", "header", "=", "struct", ".", "pack", "(", "'>BLB'", ",", "4", ",", "# version", "self", ".", "created", ",", "# creation", "self", ".", "algo_id", ")", "# public key algorithm ID", "oid", "=", "util", ".", "prefix_len", "(", "'>B'", ",", "self", ".", "curve_info", "[", "'oid'", "]", ")", "blob", "=", "self", ".", "curve_info", "[", "'serialize'", "]", "(", "self", ".", "verifying_key", ")", "return", "header", "+", "oid", "+", "blob", "+", "self", ".", "ecdh_packet" ]
Data for packet creation.
[ "Data", "for", "packet", "creation", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/protocol.py#L209-L217
train
romanz/trezor-agent
libagent/gpg/encode.py
create_subkey
def create_subkey(primary_bytes, subkey, signer_func, secret_bytes=b''): """Export new subkey to GPG primary key.""" subkey_packet = protocol.packet(tag=(7 if secret_bytes else 14), blob=(subkey.data() + secret_bytes)) packets = list(decode.parse_packets(io.BytesIO(primary_bytes))) primary, user_id, signature = packets[:3] data_to_sign = primary['_to_hash'] + subkey.data_to_hash() if subkey.ecdh: embedded_sig = None else: # Primary Key Binding Signature hashed_subpackets = [ protocol.subpacket_time(subkey.created)] # signature time unhashed_subpackets = [ protocol.subpacket(16, subkey.key_id())] # issuer key id embedded_sig = protocol.make_signature( signer_func=signer_func, data_to_sign=data_to_sign, public_algo=subkey.algo_id, sig_type=0x19, hashed_subpackets=hashed_subpackets, unhashed_subpackets=unhashed_subpackets) # Subkey Binding Signature # Key flags: https://tools.ietf.org/html/rfc4880#section-5.2.3.21 # (certify & sign) (encrypt) flags = (2) if (not subkey.ecdh) else (4 | 8) hashed_subpackets = [ protocol.subpacket_time(subkey.created), # signature time protocol.subpacket_byte(0x1B, flags)] unhashed_subpackets = [] unhashed_subpackets.append(protocol.subpacket(16, primary['key_id'])) if embedded_sig is not None: unhashed_subpackets.append(protocol.subpacket(32, embedded_sig)) unhashed_subpackets.append(protocol.CUSTOM_SUBPACKET) if not decode.has_custom_subpacket(signature): signer_func = keyring.create_agent_signer(user_id['value']) signature = protocol.make_signature( signer_func=signer_func, data_to_sign=data_to_sign, public_algo=primary['algo'], sig_type=0x18, hashed_subpackets=hashed_subpackets, unhashed_subpackets=unhashed_subpackets) sign_packet = protocol.packet(tag=2, blob=signature) return primary_bytes + subkey_packet + sign_packet
python
def create_subkey(primary_bytes, subkey, signer_func, secret_bytes=b''): """Export new subkey to GPG primary key.""" subkey_packet = protocol.packet(tag=(7 if secret_bytes else 14), blob=(subkey.data() + secret_bytes)) packets = list(decode.parse_packets(io.BytesIO(primary_bytes))) primary, user_id, signature = packets[:3] data_to_sign = primary['_to_hash'] + subkey.data_to_hash() if subkey.ecdh: embedded_sig = None else: # Primary Key Binding Signature hashed_subpackets = [ protocol.subpacket_time(subkey.created)] # signature time unhashed_subpackets = [ protocol.subpacket(16, subkey.key_id())] # issuer key id embedded_sig = protocol.make_signature( signer_func=signer_func, data_to_sign=data_to_sign, public_algo=subkey.algo_id, sig_type=0x19, hashed_subpackets=hashed_subpackets, unhashed_subpackets=unhashed_subpackets) # Subkey Binding Signature # Key flags: https://tools.ietf.org/html/rfc4880#section-5.2.3.21 # (certify & sign) (encrypt) flags = (2) if (not subkey.ecdh) else (4 | 8) hashed_subpackets = [ protocol.subpacket_time(subkey.created), # signature time protocol.subpacket_byte(0x1B, flags)] unhashed_subpackets = [] unhashed_subpackets.append(protocol.subpacket(16, primary['key_id'])) if embedded_sig is not None: unhashed_subpackets.append(protocol.subpacket(32, embedded_sig)) unhashed_subpackets.append(protocol.CUSTOM_SUBPACKET) if not decode.has_custom_subpacket(signature): signer_func = keyring.create_agent_signer(user_id['value']) signature = protocol.make_signature( signer_func=signer_func, data_to_sign=data_to_sign, public_algo=primary['algo'], sig_type=0x18, hashed_subpackets=hashed_subpackets, unhashed_subpackets=unhashed_subpackets) sign_packet = protocol.packet(tag=2, blob=signature) return primary_bytes + subkey_packet + sign_packet
[ "def", "create_subkey", "(", "primary_bytes", ",", "subkey", ",", "signer_func", ",", "secret_bytes", "=", "b''", ")", ":", "subkey_packet", "=", "protocol", ".", "packet", "(", "tag", "=", "(", "7", "if", "secret_bytes", "else", "14", ")", ",", "blob", "=", "(", "subkey", ".", "data", "(", ")", "+", "secret_bytes", ")", ")", "packets", "=", "list", "(", "decode", ".", "parse_packets", "(", "io", ".", "BytesIO", "(", "primary_bytes", ")", ")", ")", "primary", ",", "user_id", ",", "signature", "=", "packets", "[", ":", "3", "]", "data_to_sign", "=", "primary", "[", "'_to_hash'", "]", "+", "subkey", ".", "data_to_hash", "(", ")", "if", "subkey", ".", "ecdh", ":", "embedded_sig", "=", "None", "else", ":", "# Primary Key Binding Signature", "hashed_subpackets", "=", "[", "protocol", ".", "subpacket_time", "(", "subkey", ".", "created", ")", "]", "# signature time", "unhashed_subpackets", "=", "[", "protocol", ".", "subpacket", "(", "16", ",", "subkey", ".", "key_id", "(", ")", ")", "]", "# issuer key id", "embedded_sig", "=", "protocol", ".", "make_signature", "(", "signer_func", "=", "signer_func", ",", "data_to_sign", "=", "data_to_sign", ",", "public_algo", "=", "subkey", ".", "algo_id", ",", "sig_type", "=", "0x19", ",", "hashed_subpackets", "=", "hashed_subpackets", ",", "unhashed_subpackets", "=", "unhashed_subpackets", ")", "# Subkey Binding Signature", "# Key flags: https://tools.ietf.org/html/rfc4880#section-5.2.3.21", "# (certify & sign) (encrypt)", "flags", "=", "(", "2", ")", "if", "(", "not", "subkey", ".", "ecdh", ")", "else", "(", "4", "|", "8", ")", "hashed_subpackets", "=", "[", "protocol", ".", "subpacket_time", "(", "subkey", ".", "created", ")", ",", "# signature time", "protocol", ".", "subpacket_byte", "(", "0x1B", ",", "flags", ")", "]", "unhashed_subpackets", "=", "[", "]", "unhashed_subpackets", ".", "append", "(", "protocol", ".", "subpacket", "(", "16", ",", "primary", "[", "'key_id'", "]", ")", ")", "if", "embedded_sig", "is", "not", "None", ":", "unhashed_subpackets", ".", "append", "(", "protocol", ".", "subpacket", "(", "32", ",", "embedded_sig", ")", ")", "unhashed_subpackets", ".", "append", "(", "protocol", ".", "CUSTOM_SUBPACKET", ")", "if", "not", "decode", ".", "has_custom_subpacket", "(", "signature", ")", ":", "signer_func", "=", "keyring", ".", "create_agent_signer", "(", "user_id", "[", "'value'", "]", ")", "signature", "=", "protocol", ".", "make_signature", "(", "signer_func", "=", "signer_func", ",", "data_to_sign", "=", "data_to_sign", ",", "public_algo", "=", "primary", "[", "'algo'", "]", ",", "sig_type", "=", "0x18", ",", "hashed_subpackets", "=", "hashed_subpackets", ",", "unhashed_subpackets", "=", "unhashed_subpackets", ")", "sign_packet", "=", "protocol", ".", "packet", "(", "tag", "=", "2", ",", "blob", "=", "signature", ")", "return", "primary_bytes", "+", "subkey_packet", "+", "sign_packet" ]
Export new subkey to GPG primary key.
[ "Export", "new", "subkey", "to", "GPG", "primary", "key", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/encode.py#L51-L103
train
romanz/trezor-agent
libagent/gpg/__init__.py
verify_gpg_version
def verify_gpg_version(): """Make sure that the installed GnuPG is not too old.""" existing_gpg = keyring.gpg_version().decode('ascii') required_gpg = '>=2.1.11' msg = 'Existing GnuPG has version "{}" ({} required)'.format(existing_gpg, required_gpg) if not semver.match(existing_gpg, required_gpg): log.error(msg)
python
def verify_gpg_version(): """Make sure that the installed GnuPG is not too old.""" existing_gpg = keyring.gpg_version().decode('ascii') required_gpg = '>=2.1.11' msg = 'Existing GnuPG has version "{}" ({} required)'.format(existing_gpg, required_gpg) if not semver.match(existing_gpg, required_gpg): log.error(msg)
[ "def", "verify_gpg_version", "(", ")", ":", "existing_gpg", "=", "keyring", ".", "gpg_version", "(", ")", ".", "decode", "(", "'ascii'", ")", "required_gpg", "=", "'>=2.1.11'", "msg", "=", "'Existing GnuPG has version \"{}\" ({} required)'", ".", "format", "(", "existing_gpg", ",", "required_gpg", ")", "if", "not", "semver", ".", "match", "(", "existing_gpg", ",", "required_gpg", ")", ":", "log", ".", "error", "(", "msg", ")" ]
Make sure that the installed GnuPG is not too old.
[ "Make", "sure", "that", "the", "installed", "GnuPG", "is", "not", "too", "old", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/__init__.py#L83-L90
train
romanz/trezor-agent
libagent/gpg/__init__.py
check_output
def check_output(args): """Runs command and returns the output as string.""" log.debug('run: %s', args) out = subprocess.check_output(args=args).decode('utf-8') log.debug('out: %r', out) return out
python
def check_output(args): """Runs command and returns the output as string.""" log.debug('run: %s', args) out = subprocess.check_output(args=args).decode('utf-8') log.debug('out: %r', out) return out
[ "def", "check_output", "(", "args", ")", ":", "log", ".", "debug", "(", "'run: %s'", ",", "args", ")", "out", "=", "subprocess", ".", "check_output", "(", "args", "=", "args", ")", ".", "decode", "(", "'utf-8'", ")", "log", ".", "debug", "(", "'out: %r'", ",", "out", ")", "return", "out" ]
Runs command and returns the output as string.
[ "Runs", "command", "and", "returns", "the", "output", "as", "string", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/__init__.py#L93-L98
train
romanz/trezor-agent
libagent/gpg/__init__.py
check_call
def check_call(args, stdin=None, env=None): """Runs command and verifies its success.""" log.debug('run: %s%s', args, ' {}'.format(env) if env else '') subprocess.check_call(args=args, stdin=stdin, env=env)
python
def check_call(args, stdin=None, env=None): """Runs command and verifies its success.""" log.debug('run: %s%s', args, ' {}'.format(env) if env else '') subprocess.check_call(args=args, stdin=stdin, env=env)
[ "def", "check_call", "(", "args", ",", "stdin", "=", "None", ",", "env", "=", "None", ")", ":", "log", ".", "debug", "(", "'run: %s%s'", ",", "args", ",", "' {}'", ".", "format", "(", "env", ")", "if", "env", "else", "''", ")", "subprocess", ".", "check_call", "(", "args", "=", "args", ",", "stdin", "=", "stdin", ",", "env", "=", "env", ")" ]
Runs command and verifies its success.
[ "Runs", "command", "and", "verifies", "its", "success", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/__init__.py#L101-L104
train
romanz/trezor-agent
libagent/gpg/__init__.py
write_file
def write_file(path, data): """Writes data to specified path.""" with open(path, 'w') as f: log.debug('setting %s contents:\n%s', path, data) f.write(data) return f
python
def write_file(path, data): """Writes data to specified path.""" with open(path, 'w') as f: log.debug('setting %s contents:\n%s', path, data) f.write(data) return f
[ "def", "write_file", "(", "path", ",", "data", ")", ":", "with", "open", "(", "path", ",", "'w'", ")", "as", "f", ":", "log", ".", "debug", "(", "'setting %s contents:\\n%s'", ",", "path", ",", "data", ")", "f", ".", "write", "(", "data", ")", "return", "f" ]
Writes data to specified path.
[ "Writes", "data", "to", "specified", "path", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/__init__.py#L107-L112
train
romanz/trezor-agent
libagent/gpg/__init__.py
run_agent
def run_agent(device_type): """Run a simple GPG-agent server.""" p = argparse.ArgumentParser() p.add_argument('--homedir', default=os.environ.get('GNUPGHOME')) p.add_argument('-v', '--verbose', default=0, action='count') p.add_argument('--server', default=False, action='store_true', help='Use stdin/stdout for communication with GPG.') p.add_argument('--pin-entry-binary', type=str, default='pinentry', help='Path to PIN entry UI helper.') p.add_argument('--passphrase-entry-binary', type=str, default='pinentry', help='Path to passphrase entry UI helper.') p.add_argument('--cache-expiry-seconds', type=float, default=float('inf'), help='Expire passphrase from cache after this duration.') args, _ = p.parse_known_args() assert args.homedir log_file = os.path.join(args.homedir, 'gpg-agent.log') util.setup_logging(verbosity=args.verbose, filename=log_file) log.debug('sys.argv: %s', sys.argv) log.debug('os.environ: %s', os.environ) log.debug('pid: %d, parent pid: %d', os.getpid(), os.getppid()) try: env = {'GNUPGHOME': args.homedir, 'PATH': os.environ['PATH']} pubkey_bytes = keyring.export_public_keys(env=env) device_type.ui = device.ui.UI(device_type=device_type, config=vars(args)) device_type.ui.cached_passphrase_ack = util.ExpiringCache( seconds=float(args.cache_expiry_seconds)) handler = agent.Handler(device=device_type(), pubkey_bytes=pubkey_bytes) sock_server = _server_from_assuan_fd(os.environ) if sock_server is None: sock_server = _server_from_sock_path(env) with sock_server as sock: for conn in agent.yield_connections(sock): with contextlib.closing(conn): try: handler.handle(conn) except agent.AgentStop: log.info('stopping gpg-agent') return except IOError as e: log.info('connection closed: %s', e) return except Exception as e: # pylint: disable=broad-except log.exception('handler failed: %s', e) except Exception as e: # pylint: disable=broad-except log.exception('gpg-agent failed: %s', e)
python
def run_agent(device_type): """Run a simple GPG-agent server.""" p = argparse.ArgumentParser() p.add_argument('--homedir', default=os.environ.get('GNUPGHOME')) p.add_argument('-v', '--verbose', default=0, action='count') p.add_argument('--server', default=False, action='store_true', help='Use stdin/stdout for communication with GPG.') p.add_argument('--pin-entry-binary', type=str, default='pinentry', help='Path to PIN entry UI helper.') p.add_argument('--passphrase-entry-binary', type=str, default='pinentry', help='Path to passphrase entry UI helper.') p.add_argument('--cache-expiry-seconds', type=float, default=float('inf'), help='Expire passphrase from cache after this duration.') args, _ = p.parse_known_args() assert args.homedir log_file = os.path.join(args.homedir, 'gpg-agent.log') util.setup_logging(verbosity=args.verbose, filename=log_file) log.debug('sys.argv: %s', sys.argv) log.debug('os.environ: %s', os.environ) log.debug('pid: %d, parent pid: %d', os.getpid(), os.getppid()) try: env = {'GNUPGHOME': args.homedir, 'PATH': os.environ['PATH']} pubkey_bytes = keyring.export_public_keys(env=env) device_type.ui = device.ui.UI(device_type=device_type, config=vars(args)) device_type.ui.cached_passphrase_ack = util.ExpiringCache( seconds=float(args.cache_expiry_seconds)) handler = agent.Handler(device=device_type(), pubkey_bytes=pubkey_bytes) sock_server = _server_from_assuan_fd(os.environ) if sock_server is None: sock_server = _server_from_sock_path(env) with sock_server as sock: for conn in agent.yield_connections(sock): with contextlib.closing(conn): try: handler.handle(conn) except agent.AgentStop: log.info('stopping gpg-agent') return except IOError as e: log.info('connection closed: %s', e) return except Exception as e: # pylint: disable=broad-except log.exception('handler failed: %s', e) except Exception as e: # pylint: disable=broad-except log.exception('gpg-agent failed: %s', e)
[ "def", "run_agent", "(", "device_type", ")", ":", "p", "=", "argparse", ".", "ArgumentParser", "(", ")", "p", ".", "add_argument", "(", "'--homedir'", ",", "default", "=", "os", ".", "environ", ".", "get", "(", "'GNUPGHOME'", ")", ")", "p", ".", "add_argument", "(", "'-v'", ",", "'--verbose'", ",", "default", "=", "0", ",", "action", "=", "'count'", ")", "p", ".", "add_argument", "(", "'--server'", ",", "default", "=", "False", ",", "action", "=", "'store_true'", ",", "help", "=", "'Use stdin/stdout for communication with GPG.'", ")", "p", ".", "add_argument", "(", "'--pin-entry-binary'", ",", "type", "=", "str", ",", "default", "=", "'pinentry'", ",", "help", "=", "'Path to PIN entry UI helper.'", ")", "p", ".", "add_argument", "(", "'--passphrase-entry-binary'", ",", "type", "=", "str", ",", "default", "=", "'pinentry'", ",", "help", "=", "'Path to passphrase entry UI helper.'", ")", "p", ".", "add_argument", "(", "'--cache-expiry-seconds'", ",", "type", "=", "float", ",", "default", "=", "float", "(", "'inf'", ")", ",", "help", "=", "'Expire passphrase from cache after this duration.'", ")", "args", ",", "_", "=", "p", ".", "parse_known_args", "(", ")", "assert", "args", ".", "homedir", "log_file", "=", "os", ".", "path", ".", "join", "(", "args", ".", "homedir", ",", "'gpg-agent.log'", ")", "util", ".", "setup_logging", "(", "verbosity", "=", "args", ".", "verbose", ",", "filename", "=", "log_file", ")", "log", ".", "debug", "(", "'sys.argv: %s'", ",", "sys", ".", "argv", ")", "log", ".", "debug", "(", "'os.environ: %s'", ",", "os", ".", "environ", ")", "log", ".", "debug", "(", "'pid: %d, parent pid: %d'", ",", "os", ".", "getpid", "(", ")", ",", "os", ".", "getppid", "(", ")", ")", "try", ":", "env", "=", "{", "'GNUPGHOME'", ":", "args", ".", "homedir", ",", "'PATH'", ":", "os", ".", "environ", "[", "'PATH'", "]", "}", "pubkey_bytes", "=", "keyring", ".", "export_public_keys", "(", "env", "=", "env", ")", "device_type", ".", "ui", "=", "device", ".", "ui", ".", "UI", "(", "device_type", "=", "device_type", ",", "config", "=", "vars", "(", "args", ")", ")", "device_type", ".", "ui", ".", "cached_passphrase_ack", "=", "util", ".", "ExpiringCache", "(", "seconds", "=", "float", "(", "args", ".", "cache_expiry_seconds", ")", ")", "handler", "=", "agent", ".", "Handler", "(", "device", "=", "device_type", "(", ")", ",", "pubkey_bytes", "=", "pubkey_bytes", ")", "sock_server", "=", "_server_from_assuan_fd", "(", "os", ".", "environ", ")", "if", "sock_server", "is", "None", ":", "sock_server", "=", "_server_from_sock_path", "(", "env", ")", "with", "sock_server", "as", "sock", ":", "for", "conn", "in", "agent", ".", "yield_connections", "(", "sock", ")", ":", "with", "contextlib", ".", "closing", "(", "conn", ")", ":", "try", ":", "handler", ".", "handle", "(", "conn", ")", "except", "agent", ".", "AgentStop", ":", "log", ".", "info", "(", "'stopping gpg-agent'", ")", "return", "except", "IOError", "as", "e", ":", "log", ".", "info", "(", "'connection closed: %s'", ",", "e", ")", "return", "except", "Exception", "as", "e", ":", "# pylint: disable=broad-except", "log", ".", "exception", "(", "'handler failed: %s'", ",", "e", ")", "except", "Exception", "as", "e", ":", "# pylint: disable=broad-except", "log", ".", "exception", "(", "'gpg-agent failed: %s'", ",", "e", ")" ]
Run a simple GPG-agent server.
[ "Run", "a", "simple", "GPG", "-", "agent", "server", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/gpg/__init__.py#L222-L276
train
romanz/trezor-agent
libagent/device/trezor_defs.py
find_device
def find_device(): """Selects a transport based on `TREZOR_PATH` environment variable. If unset, picks first connected device. """ try: return get_transport(os.environ.get("TREZOR_PATH")) except Exception as e: # pylint: disable=broad-except log.debug("Failed to find a Trezor device: %s", e)
python
def find_device(): """Selects a transport based on `TREZOR_PATH` environment variable. If unset, picks first connected device. """ try: return get_transport(os.environ.get("TREZOR_PATH")) except Exception as e: # pylint: disable=broad-except log.debug("Failed to find a Trezor device: %s", e)
[ "def", "find_device", "(", ")", ":", "try", ":", "return", "get_transport", "(", "os", ".", "environ", ".", "get", "(", "\"TREZOR_PATH\"", ")", ")", "except", "Exception", "as", "e", ":", "# pylint: disable=broad-except", "log", ".", "debug", "(", "\"Failed to find a Trezor device: %s\"", ",", "e", ")" ]
Selects a transport based on `TREZOR_PATH` environment variable. If unset, picks first connected device.
[ "Selects", "a", "transport", "based", "on", "TREZOR_PATH", "environment", "variable", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/trezor_defs.py#L22-L30
train
romanz/trezor-agent
libagent/device/ledger.py
_convert_public_key
def _convert_public_key(ecdsa_curve_name, result): """Convert Ledger reply into PublicKey object.""" if ecdsa_curve_name == 'nist256p1': if (result[64] & 1) != 0: result = bytearray([0x03]) + result[1:33] else: result = bytearray([0x02]) + result[1:33] else: result = result[1:] keyX = bytearray(result[0:32]) keyY = bytearray(result[32:][::-1]) if (keyX[31] & 1) != 0: keyY[31] |= 0x80 result = b'\x00' + bytes(keyY) return bytes(result)
python
def _convert_public_key(ecdsa_curve_name, result): """Convert Ledger reply into PublicKey object.""" if ecdsa_curve_name == 'nist256p1': if (result[64] & 1) != 0: result = bytearray([0x03]) + result[1:33] else: result = bytearray([0x02]) + result[1:33] else: result = result[1:] keyX = bytearray(result[0:32]) keyY = bytearray(result[32:][::-1]) if (keyX[31] & 1) != 0: keyY[31] |= 0x80 result = b'\x00' + bytes(keyY) return bytes(result)
[ "def", "_convert_public_key", "(", "ecdsa_curve_name", ",", "result", ")", ":", "if", "ecdsa_curve_name", "==", "'nist256p1'", ":", "if", "(", "result", "[", "64", "]", "&", "1", ")", "!=", "0", ":", "result", "=", "bytearray", "(", "[", "0x03", "]", ")", "+", "result", "[", "1", ":", "33", "]", "else", ":", "result", "=", "bytearray", "(", "[", "0x02", "]", ")", "+", "result", "[", "1", ":", "33", "]", "else", ":", "result", "=", "result", "[", "1", ":", "]", "keyX", "=", "bytearray", "(", "result", "[", "0", ":", "32", "]", ")", "keyY", "=", "bytearray", "(", "result", "[", "32", ":", "]", "[", ":", ":", "-", "1", "]", ")", "if", "(", "keyX", "[", "31", "]", "&", "1", ")", "!=", "0", ":", "keyY", "[", "31", "]", "|=", "0x80", "result", "=", "b'\\x00'", "+", "bytes", "(", "keyY", ")", "return", "bytes", "(", "result", ")" ]
Convert Ledger reply into PublicKey object.
[ "Convert", "Ledger", "reply", "into", "PublicKey", "object", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/ledger.py#L19-L33
train
romanz/trezor-agent
libagent/device/ledger.py
LedgerNanoS.connect
def connect(self): """Enumerate and connect to the first USB HID interface.""" try: return comm.getDongle() except comm.CommException as e: raise interface.NotFoundError( '{} not connected: "{}"'.format(self, e))
python
def connect(self): """Enumerate and connect to the first USB HID interface.""" try: return comm.getDongle() except comm.CommException as e: raise interface.NotFoundError( '{} not connected: "{}"'.format(self, e))
[ "def", "connect", "(", "self", ")", ":", "try", ":", "return", "comm", ".", "getDongle", "(", ")", "except", "comm", ".", "CommException", "as", "e", ":", "raise", "interface", ".", "NotFoundError", "(", "'{} not connected: \"{}\"'", ".", "format", "(", "self", ",", "e", ")", ")" ]
Enumerate and connect to the first USB HID interface.
[ "Enumerate", "and", "connect", "to", "the", "first", "USB", "HID", "interface", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/ledger.py#L44-L50
train
romanz/trezor-agent
libagent/device/ledger.py
LedgerNanoS.pubkey
def pubkey(self, identity, ecdh=False): """Get PublicKey object for specified BIP32 address and elliptic curve.""" curve_name = identity.get_curve_name(ecdh) path = _expand_path(identity.get_bip32_address(ecdh)) if curve_name == 'nist256p1': p2 = '01' else: p2 = '02' apdu = '800200' + p2 apdu = binascii.unhexlify(apdu) apdu += bytearray([len(path) + 1, len(path) // 4]) apdu += path log.debug('apdu: %r', apdu) result = bytearray(self.conn.exchange(bytes(apdu))) log.debug('result: %r', result) return _convert_public_key(curve_name, result[1:])
python
def pubkey(self, identity, ecdh=False): """Get PublicKey object for specified BIP32 address and elliptic curve.""" curve_name = identity.get_curve_name(ecdh) path = _expand_path(identity.get_bip32_address(ecdh)) if curve_name == 'nist256p1': p2 = '01' else: p2 = '02' apdu = '800200' + p2 apdu = binascii.unhexlify(apdu) apdu += bytearray([len(path) + 1, len(path) // 4]) apdu += path log.debug('apdu: %r', apdu) result = bytearray(self.conn.exchange(bytes(apdu))) log.debug('result: %r', result) return _convert_public_key(curve_name, result[1:])
[ "def", "pubkey", "(", "self", ",", "identity", ",", "ecdh", "=", "False", ")", ":", "curve_name", "=", "identity", ".", "get_curve_name", "(", "ecdh", ")", "path", "=", "_expand_path", "(", "identity", ".", "get_bip32_address", "(", "ecdh", ")", ")", "if", "curve_name", "==", "'nist256p1'", ":", "p2", "=", "'01'", "else", ":", "p2", "=", "'02'", "apdu", "=", "'800200'", "+", "p2", "apdu", "=", "binascii", ".", "unhexlify", "(", "apdu", ")", "apdu", "+=", "bytearray", "(", "[", "len", "(", "path", ")", "+", "1", ",", "len", "(", "path", ")", "//", "4", "]", ")", "apdu", "+=", "path", "log", ".", "debug", "(", "'apdu: %r'", ",", "apdu", ")", "result", "=", "bytearray", "(", "self", ".", "conn", ".", "exchange", "(", "bytes", "(", "apdu", ")", ")", ")", "log", ".", "debug", "(", "'result: %r'", ",", "result", ")", "return", "_convert_public_key", "(", "curve_name", ",", "result", "[", "1", ":", "]", ")" ]
Get PublicKey object for specified BIP32 address and elliptic curve.
[ "Get", "PublicKey", "object", "for", "specified", "BIP32", "address", "and", "elliptic", "curve", "." ]
513b1259c4d7aca5f88cd958edc11828d0712f1b
https://github.com/romanz/trezor-agent/blob/513b1259c4d7aca5f88cd958edc11828d0712f1b/libagent/device/ledger.py#L52-L67
train
inonit/drf-haystack
ez_setup.py
download_setuptools
def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir, delay=15): """Download distribute from a specified location and return its filename `version` should be a valid distribute version number that is available as an egg for download under the `download_base` URL (which should end with a '/'). `to_dir` is the directory where the egg will be downloaded. `delay` is the number of seconds to pause before an actual download attempt. """ # making sure we use the absolute path to_dir = os.path.abspath(to_dir) try: from urllib.request import urlopen except ImportError: from urllib2 import urlopen tgz_name = "distribute-%s.tar.gz" % version url = download_base + tgz_name saveto = os.path.join(to_dir, tgz_name) src = dst = None if not os.path.exists(saveto): # Avoid repeated downloads try: log.warn("Downloading %s", url) src = urlopen(url) # Read/write all in one block, so we don't create a corrupt file # if the download is interrupted. data = src.read() dst = open(saveto, "wb") dst.write(data) finally: if src: src.close() if dst: dst.close() return os.path.realpath(saveto)
python
def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir, delay=15): """Download distribute from a specified location and return its filename `version` should be a valid distribute version number that is available as an egg for download under the `download_base` URL (which should end with a '/'). `to_dir` is the directory where the egg will be downloaded. `delay` is the number of seconds to pause before an actual download attempt. """ # making sure we use the absolute path to_dir = os.path.abspath(to_dir) try: from urllib.request import urlopen except ImportError: from urllib2 import urlopen tgz_name = "distribute-%s.tar.gz" % version url = download_base + tgz_name saveto = os.path.join(to_dir, tgz_name) src = dst = None if not os.path.exists(saveto): # Avoid repeated downloads try: log.warn("Downloading %s", url) src = urlopen(url) # Read/write all in one block, so we don't create a corrupt file # if the download is interrupted. data = src.read() dst = open(saveto, "wb") dst.write(data) finally: if src: src.close() if dst: dst.close() return os.path.realpath(saveto)
[ "def", "download_setuptools", "(", "version", "=", "DEFAULT_VERSION", ",", "download_base", "=", "DEFAULT_URL", ",", "to_dir", "=", "os", ".", "curdir", ",", "delay", "=", "15", ")", ":", "# making sure we use the absolute path", "to_dir", "=", "os", ".", "path", ".", "abspath", "(", "to_dir", ")", "try", ":", "from", "urllib", ".", "request", "import", "urlopen", "except", "ImportError", ":", "from", "urllib2", "import", "urlopen", "tgz_name", "=", "\"distribute-%s.tar.gz\"", "%", "version", "url", "=", "download_base", "+", "tgz_name", "saveto", "=", "os", ".", "path", ".", "join", "(", "to_dir", ",", "tgz_name", ")", "src", "=", "dst", "=", "None", "if", "not", "os", ".", "path", ".", "exists", "(", "saveto", ")", ":", "# Avoid repeated downloads", "try", ":", "log", ".", "warn", "(", "\"Downloading %s\"", ",", "url", ")", "src", "=", "urlopen", "(", "url", ")", "# Read/write all in one block, so we don't create a corrupt file", "# if the download is interrupted.", "data", "=", "src", ".", "read", "(", ")", "dst", "=", "open", "(", "saveto", ",", "\"wb\"", ")", "dst", ".", "write", "(", "data", ")", "finally", ":", "if", "src", ":", "src", ".", "close", "(", ")", "if", "dst", ":", "dst", ".", "close", "(", ")", "return", "os", ".", "path", ".", "realpath", "(", "saveto", ")" ]
Download distribute from a specified location and return its filename `version` should be a valid distribute version number that is available as an egg for download under the `download_base` URL (which should end with a '/'). `to_dir` is the directory where the egg will be downloaded. `delay` is the number of seconds to pause before an actual download attempt.
[ "Download", "distribute", "from", "a", "specified", "location", "and", "return", "its", "filename" ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/ez_setup.py#L170-L204
train
inonit/drf-haystack
drf_haystack/query.py
BaseQueryBuilder.tokenize
def tokenize(stream, separator): """ Tokenize and yield query parameter values. :param stream: Input value :param separator: Character to use to separate the tokens. :return: """ for value in stream: for token in value.split(separator): if token: yield token.strip()
python
def tokenize(stream, separator): """ Tokenize and yield query parameter values. :param stream: Input value :param separator: Character to use to separate the tokens. :return: """ for value in stream: for token in value.split(separator): if token: yield token.strip()
[ "def", "tokenize", "(", "stream", ",", "separator", ")", ":", "for", "value", "in", "stream", ":", "for", "token", "in", "value", ".", "split", "(", "separator", ")", ":", "if", "token", ":", "yield", "token", ".", "strip", "(", ")" ]
Tokenize and yield query parameter values. :param stream: Input value :param separator: Character to use to separate the tokens. :return:
[ "Tokenize", "and", "yield", "query", "parameter", "values", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/query.py#L34-L45
train
inonit/drf-haystack
drf_haystack/query.py
FilterQueryBuilder.build_query
def build_query(self, **filters): """ Creates a single SQ filter from querystring parameters that correspond to the SearchIndex fields that have been "registered" in `view.fields`. Default behavior is to `OR` terms for the same parameters, and `AND` between parameters. Any querystring parameters that are not registered in `view.fields` will be ignored. :param dict[str, list[str]] filters: is an expanded QueryDict or a mapping of keys to a list of parameters. """ applicable_filters = [] applicable_exclusions = [] for param, value in filters.items(): excluding_term = False param_parts = param.split("__") base_param = param_parts[0] # only test against field without lookup negation_keyword = constants.DRF_HAYSTACK_NEGATION_KEYWORD if len(param_parts) > 1 and param_parts[1] == negation_keyword: excluding_term = True param = param.replace("__%s" % negation_keyword, "") # haystack wouldn't understand our negation if self.view.serializer_class: if hasattr(self.view.serializer_class.Meta, 'field_aliases'): old_base = base_param base_param = self.view.serializer_class.Meta.field_aliases.get(base_param, base_param) param = param.replace(old_base, base_param) # need to replace the alias fields = getattr(self.view.serializer_class.Meta, 'fields', []) exclude = getattr(self.view.serializer_class.Meta, 'exclude', []) search_fields = getattr(self.view.serializer_class.Meta, 'search_fields', []) # Skip if the parameter is not listed in the serializer's `fields` # or if it's in the `exclude` list. if ((fields or search_fields) and base_param not in chain(fields, search_fields)) or base_param in exclude or not value: continue field_queries = [] if len(param_parts) > 1 and param_parts[-1] in ('in', 'range'): # `in` and `range` filters expects a list of values field_queries.append(self.view.query_object((param, list(self.tokenize(value, self.view.lookup_sep))))) else: for token in self.tokenize(value, self.view.lookup_sep): field_queries.append(self.view.query_object((param, token))) field_queries = [fq for fq in field_queries if fq] if len(field_queries) > 0: term = six.moves.reduce(operator.or_, field_queries) if excluding_term: applicable_exclusions.append(term) else: applicable_filters.append(term) applicable_filters = six.moves.reduce( self.default_operator, filter(lambda x: x, applicable_filters)) if applicable_filters else [] applicable_exclusions = six.moves.reduce( self.default_operator, filter(lambda x: x, applicable_exclusions)) if applicable_exclusions else [] return applicable_filters, applicable_exclusions
python
def build_query(self, **filters): """ Creates a single SQ filter from querystring parameters that correspond to the SearchIndex fields that have been "registered" in `view.fields`. Default behavior is to `OR` terms for the same parameters, and `AND` between parameters. Any querystring parameters that are not registered in `view.fields` will be ignored. :param dict[str, list[str]] filters: is an expanded QueryDict or a mapping of keys to a list of parameters. """ applicable_filters = [] applicable_exclusions = [] for param, value in filters.items(): excluding_term = False param_parts = param.split("__") base_param = param_parts[0] # only test against field without lookup negation_keyword = constants.DRF_HAYSTACK_NEGATION_KEYWORD if len(param_parts) > 1 and param_parts[1] == negation_keyword: excluding_term = True param = param.replace("__%s" % negation_keyword, "") # haystack wouldn't understand our negation if self.view.serializer_class: if hasattr(self.view.serializer_class.Meta, 'field_aliases'): old_base = base_param base_param = self.view.serializer_class.Meta.field_aliases.get(base_param, base_param) param = param.replace(old_base, base_param) # need to replace the alias fields = getattr(self.view.serializer_class.Meta, 'fields', []) exclude = getattr(self.view.serializer_class.Meta, 'exclude', []) search_fields = getattr(self.view.serializer_class.Meta, 'search_fields', []) # Skip if the parameter is not listed in the serializer's `fields` # or if it's in the `exclude` list. if ((fields or search_fields) and base_param not in chain(fields, search_fields)) or base_param in exclude or not value: continue field_queries = [] if len(param_parts) > 1 and param_parts[-1] in ('in', 'range'): # `in` and `range` filters expects a list of values field_queries.append(self.view.query_object((param, list(self.tokenize(value, self.view.lookup_sep))))) else: for token in self.tokenize(value, self.view.lookup_sep): field_queries.append(self.view.query_object((param, token))) field_queries = [fq for fq in field_queries if fq] if len(field_queries) > 0: term = six.moves.reduce(operator.or_, field_queries) if excluding_term: applicable_exclusions.append(term) else: applicable_filters.append(term) applicable_filters = six.moves.reduce( self.default_operator, filter(lambda x: x, applicable_filters)) if applicable_filters else [] applicable_exclusions = six.moves.reduce( self.default_operator, filter(lambda x: x, applicable_exclusions)) if applicable_exclusions else [] return applicable_filters, applicable_exclusions
[ "def", "build_query", "(", "self", ",", "*", "*", "filters", ")", ":", "applicable_filters", "=", "[", "]", "applicable_exclusions", "=", "[", "]", "for", "param", ",", "value", "in", "filters", ".", "items", "(", ")", ":", "excluding_term", "=", "False", "param_parts", "=", "param", ".", "split", "(", "\"__\"", ")", "base_param", "=", "param_parts", "[", "0", "]", "# only test against field without lookup", "negation_keyword", "=", "constants", ".", "DRF_HAYSTACK_NEGATION_KEYWORD", "if", "len", "(", "param_parts", ")", ">", "1", "and", "param_parts", "[", "1", "]", "==", "negation_keyword", ":", "excluding_term", "=", "True", "param", "=", "param", ".", "replace", "(", "\"__%s\"", "%", "negation_keyword", ",", "\"\"", ")", "# haystack wouldn't understand our negation", "if", "self", ".", "view", ".", "serializer_class", ":", "if", "hasattr", "(", "self", ".", "view", ".", "serializer_class", ".", "Meta", ",", "'field_aliases'", ")", ":", "old_base", "=", "base_param", "base_param", "=", "self", ".", "view", ".", "serializer_class", ".", "Meta", ".", "field_aliases", ".", "get", "(", "base_param", ",", "base_param", ")", "param", "=", "param", ".", "replace", "(", "old_base", ",", "base_param", ")", "# need to replace the alias", "fields", "=", "getattr", "(", "self", ".", "view", ".", "serializer_class", ".", "Meta", ",", "'fields'", ",", "[", "]", ")", "exclude", "=", "getattr", "(", "self", ".", "view", ".", "serializer_class", ".", "Meta", ",", "'exclude'", ",", "[", "]", ")", "search_fields", "=", "getattr", "(", "self", ".", "view", ".", "serializer_class", ".", "Meta", ",", "'search_fields'", ",", "[", "]", ")", "# Skip if the parameter is not listed in the serializer's `fields`", "# or if it's in the `exclude` list.", "if", "(", "(", "fields", "or", "search_fields", ")", "and", "base_param", "not", "in", "chain", "(", "fields", ",", "search_fields", ")", ")", "or", "base_param", "in", "exclude", "or", "not", "value", ":", "continue", "field_queries", "=", "[", "]", "if", "len", "(", "param_parts", ")", ">", "1", "and", "param_parts", "[", "-", "1", "]", "in", "(", "'in'", ",", "'range'", ")", ":", "# `in` and `range` filters expects a list of values", "field_queries", ".", "append", "(", "self", ".", "view", ".", "query_object", "(", "(", "param", ",", "list", "(", "self", ".", "tokenize", "(", "value", ",", "self", ".", "view", ".", "lookup_sep", ")", ")", ")", ")", ")", "else", ":", "for", "token", "in", "self", ".", "tokenize", "(", "value", ",", "self", ".", "view", ".", "lookup_sep", ")", ":", "field_queries", ".", "append", "(", "self", ".", "view", ".", "query_object", "(", "(", "param", ",", "token", ")", ")", ")", "field_queries", "=", "[", "fq", "for", "fq", "in", "field_queries", "if", "fq", "]", "if", "len", "(", "field_queries", ")", ">", "0", ":", "term", "=", "six", ".", "moves", ".", "reduce", "(", "operator", ".", "or_", ",", "field_queries", ")", "if", "excluding_term", ":", "applicable_exclusions", ".", "append", "(", "term", ")", "else", ":", "applicable_filters", ".", "append", "(", "term", ")", "applicable_filters", "=", "six", ".", "moves", ".", "reduce", "(", "self", ".", "default_operator", ",", "filter", "(", "lambda", "x", ":", "x", ",", "applicable_filters", ")", ")", "if", "applicable_filters", "else", "[", "]", "applicable_exclusions", "=", "six", ".", "moves", ".", "reduce", "(", "self", ".", "default_operator", ",", "filter", "(", "lambda", "x", ":", "x", ",", "applicable_exclusions", ")", ")", "if", "applicable_exclusions", "else", "[", "]", "return", "applicable_filters", ",", "applicable_exclusions" ]
Creates a single SQ filter from querystring parameters that correspond to the SearchIndex fields that have been "registered" in `view.fields`. Default behavior is to `OR` terms for the same parameters, and `AND` between parameters. Any querystring parameters that are not registered in `view.fields` will be ignored. :param dict[str, list[str]] filters: is an expanded QueryDict or a mapping of keys to a list of parameters.
[ "Creates", "a", "single", "SQ", "filter", "from", "querystring", "parameters", "that", "correspond", "to", "the", "SearchIndex", "fields", "that", "have", "been", "registered", "in", "view", ".", "fields", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/query.py#L89-L151
train
inonit/drf-haystack
drf_haystack/query.py
FacetQueryBuilder.build_query
def build_query(self, **filters): """ Creates a dict of dictionaries suitable for passing to the SearchQuerySet `facet`, `date_facet` or `query_facet` method. All key word arguments should be wrapped in a list. :param view: API View :param dict[str, list[str]] filters: is an expanded QueryDict or a mapping of keys to a list of parameters. """ field_facets = {} date_facets = {} query_facets = {} facet_serializer_cls = self.view.get_facet_serializer_class() if self.view.lookup_sep == ":": raise AttributeError("The %(cls)s.lookup_sep attribute conflicts with the HaystackFacetFilter " "query parameter parser. Please choose another `lookup_sep` attribute " "for %(cls)s." % {"cls": self.view.__class__.__name__}) fields = facet_serializer_cls.Meta.fields exclude = facet_serializer_cls.Meta.exclude field_options = facet_serializer_cls.Meta.field_options for field, options in filters.items(): if field not in fields or field in exclude: continue field_options = merge_dict(field_options, {field: self.parse_field_options(self.view.lookup_sep, *options)}) valid_gap = ("year", "month", "day", "hour", "minute", "second") for field, options in field_options.items(): if any([k in options for k in ("start_date", "end_date", "gap_by", "gap_amount")]): if not all(("start_date", "end_date", "gap_by" in options)): raise ValueError("Date faceting requires at least 'start_date', 'end_date' " "and 'gap_by' to be set.") if not options["gap_by"] in valid_gap: raise ValueError("The 'gap_by' parameter must be one of %s." % ", ".join(valid_gap)) options.setdefault("gap_amount", 1) date_facets[field] = field_options[field] else: field_facets[field] = field_options[field] return { "date_facets": date_facets, "field_facets": field_facets, "query_facets": query_facets }
python
def build_query(self, **filters): """ Creates a dict of dictionaries suitable for passing to the SearchQuerySet `facet`, `date_facet` or `query_facet` method. All key word arguments should be wrapped in a list. :param view: API View :param dict[str, list[str]] filters: is an expanded QueryDict or a mapping of keys to a list of parameters. """ field_facets = {} date_facets = {} query_facets = {} facet_serializer_cls = self.view.get_facet_serializer_class() if self.view.lookup_sep == ":": raise AttributeError("The %(cls)s.lookup_sep attribute conflicts with the HaystackFacetFilter " "query parameter parser. Please choose another `lookup_sep` attribute " "for %(cls)s." % {"cls": self.view.__class__.__name__}) fields = facet_serializer_cls.Meta.fields exclude = facet_serializer_cls.Meta.exclude field_options = facet_serializer_cls.Meta.field_options for field, options in filters.items(): if field not in fields or field in exclude: continue field_options = merge_dict(field_options, {field: self.parse_field_options(self.view.lookup_sep, *options)}) valid_gap = ("year", "month", "day", "hour", "minute", "second") for field, options in field_options.items(): if any([k in options for k in ("start_date", "end_date", "gap_by", "gap_amount")]): if not all(("start_date", "end_date", "gap_by" in options)): raise ValueError("Date faceting requires at least 'start_date', 'end_date' " "and 'gap_by' to be set.") if not options["gap_by"] in valid_gap: raise ValueError("The 'gap_by' parameter must be one of %s." % ", ".join(valid_gap)) options.setdefault("gap_amount", 1) date_facets[field] = field_options[field] else: field_facets[field] = field_options[field] return { "date_facets": date_facets, "field_facets": field_facets, "query_facets": query_facets }
[ "def", "build_query", "(", "self", ",", "*", "*", "filters", ")", ":", "field_facets", "=", "{", "}", "date_facets", "=", "{", "}", "query_facets", "=", "{", "}", "facet_serializer_cls", "=", "self", ".", "view", ".", "get_facet_serializer_class", "(", ")", "if", "self", ".", "view", ".", "lookup_sep", "==", "\":\"", ":", "raise", "AttributeError", "(", "\"The %(cls)s.lookup_sep attribute conflicts with the HaystackFacetFilter \"", "\"query parameter parser. Please choose another `lookup_sep` attribute \"", "\"for %(cls)s.\"", "%", "{", "\"cls\"", ":", "self", ".", "view", ".", "__class__", ".", "__name__", "}", ")", "fields", "=", "facet_serializer_cls", ".", "Meta", ".", "fields", "exclude", "=", "facet_serializer_cls", ".", "Meta", ".", "exclude", "field_options", "=", "facet_serializer_cls", ".", "Meta", ".", "field_options", "for", "field", ",", "options", "in", "filters", ".", "items", "(", ")", ":", "if", "field", "not", "in", "fields", "or", "field", "in", "exclude", ":", "continue", "field_options", "=", "merge_dict", "(", "field_options", ",", "{", "field", ":", "self", ".", "parse_field_options", "(", "self", ".", "view", ".", "lookup_sep", ",", "*", "options", ")", "}", ")", "valid_gap", "=", "(", "\"year\"", ",", "\"month\"", ",", "\"day\"", ",", "\"hour\"", ",", "\"minute\"", ",", "\"second\"", ")", "for", "field", ",", "options", "in", "field_options", ".", "items", "(", ")", ":", "if", "any", "(", "[", "k", "in", "options", "for", "k", "in", "(", "\"start_date\"", ",", "\"end_date\"", ",", "\"gap_by\"", ",", "\"gap_amount\"", ")", "]", ")", ":", "if", "not", "all", "(", "(", "\"start_date\"", ",", "\"end_date\"", ",", "\"gap_by\"", "in", "options", ")", ")", ":", "raise", "ValueError", "(", "\"Date faceting requires at least 'start_date', 'end_date' \"", "\"and 'gap_by' to be set.\"", ")", "if", "not", "options", "[", "\"gap_by\"", "]", "in", "valid_gap", ":", "raise", "ValueError", "(", "\"The 'gap_by' parameter must be one of %s.\"", "%", "\", \"", ".", "join", "(", "valid_gap", ")", ")", "options", ".", "setdefault", "(", "\"gap_amount\"", ",", "1", ")", "date_facets", "[", "field", "]", "=", "field_options", "[", "field", "]", "else", ":", "field_facets", "[", "field", "]", "=", "field_options", "[", "field", "]", "return", "{", "\"date_facets\"", ":", "date_facets", ",", "\"field_facets\"", ":", "field_facets", ",", "\"query_facets\"", ":", "query_facets", "}" ]
Creates a dict of dictionaries suitable for passing to the SearchQuerySet `facet`, `date_facet` or `query_facet` method. All key word arguments should be wrapped in a list. :param view: API View :param dict[str, list[str]] filters: is an expanded QueryDict or a mapping of keys to a list of parameters.
[ "Creates", "a", "dict", "of", "dictionaries", "suitable", "for", "passing", "to", "the", "SearchQuerySet", "facet", "date_facet", "or", "query_facet", "method", ".", "All", "key", "word", "arguments", "should", "be", "wrapped", "in", "a", "list", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/query.py#L159-L210
train
inonit/drf-haystack
drf_haystack/query.py
FacetQueryBuilder.parse_field_options
def parse_field_options(self, *options): """ Parse the field options query string and return it as a dictionary. """ defaults = {} for option in options: if isinstance(option, six.text_type): tokens = [token.strip() for token in option.split(self.view.lookup_sep)] for token in tokens: if not len(token.split(":")) == 2: warnings.warn("The %s token is not properly formatted. Tokens need to be " "formatted as 'token:value' pairs." % token) continue param, value = token.split(":", 1) if any([k == param for k in ("start_date", "end_date", "gap_amount")]): if param in ("start_date", "end_date"): value = parser.parse(value) if param == "gap_amount": value = int(value) defaults[param] = value return defaults
python
def parse_field_options(self, *options): """ Parse the field options query string and return it as a dictionary. """ defaults = {} for option in options: if isinstance(option, six.text_type): tokens = [token.strip() for token in option.split(self.view.lookup_sep)] for token in tokens: if not len(token.split(":")) == 2: warnings.warn("The %s token is not properly formatted. Tokens need to be " "formatted as 'token:value' pairs." % token) continue param, value = token.split(":", 1) if any([k == param for k in ("start_date", "end_date", "gap_amount")]): if param in ("start_date", "end_date"): value = parser.parse(value) if param == "gap_amount": value = int(value) defaults[param] = value return defaults
[ "def", "parse_field_options", "(", "self", ",", "*", "options", ")", ":", "defaults", "=", "{", "}", "for", "option", "in", "options", ":", "if", "isinstance", "(", "option", ",", "six", ".", "text_type", ")", ":", "tokens", "=", "[", "token", ".", "strip", "(", ")", "for", "token", "in", "option", ".", "split", "(", "self", ".", "view", ".", "lookup_sep", ")", "]", "for", "token", "in", "tokens", ":", "if", "not", "len", "(", "token", ".", "split", "(", "\":\"", ")", ")", "==", "2", ":", "warnings", ".", "warn", "(", "\"The %s token is not properly formatted. Tokens need to be \"", "\"formatted as 'token:value' pairs.\"", "%", "token", ")", "continue", "param", ",", "value", "=", "token", ".", "split", "(", "\":\"", ",", "1", ")", "if", "any", "(", "[", "k", "==", "param", "for", "k", "in", "(", "\"start_date\"", ",", "\"end_date\"", ",", "\"gap_amount\"", ")", "]", ")", ":", "if", "param", "in", "(", "\"start_date\"", ",", "\"end_date\"", ")", ":", "value", "=", "parser", ".", "parse", "(", "value", ")", "if", "param", "==", "\"gap_amount\"", ":", "value", "=", "int", "(", "value", ")", "defaults", "[", "param", "]", "=", "value", "return", "defaults" ]
Parse the field options query string and return it as a dictionary.
[ "Parse", "the", "field", "options", "query", "string", "and", "return", "it", "as", "a", "dictionary", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/query.py#L212-L239
train
inonit/drf-haystack
drf_haystack/query.py
SpatialQueryBuilder.build_query
def build_query(self, **filters): """ Build queries for geo spatial filtering. Expected query parameters are: - a `unit=value` parameter where the unit is a valid UNIT in the `django.contrib.gis.measure.Distance` class. - `from` which must be a comma separated latitude and longitude. Example query: /api/v1/search/?km=10&from=59.744076,10.152045 Will perform a `dwithin` query within 10 km from the point with latitude 59.744076 and longitude 10.152045. """ applicable_filters = None filters = dict((k, filters[k]) for k in chain(self.D.UNITS.keys(), [constants.DRF_HAYSTACK_SPATIAL_QUERY_PARAM]) if k in filters) distance = dict((k, v) for k, v in filters.items() if k in self.D.UNITS.keys()) try: latitude, longitude = map(float, self.tokenize(filters[constants.DRF_HAYSTACK_SPATIAL_QUERY_PARAM], self.view.lookup_sep)) point = self.Point(longitude, latitude, srid=constants.GEO_SRID) except ValueError: raise ValueError("Cannot convert `from=latitude,longitude` query parameter to " "float values. Make sure to provide numerical values only!") except KeyError: # If the user has not provided any `from` query string parameter, # just return. pass else: for unit in distance.keys(): if not len(distance[unit]) == 1: raise ValueError("Each unit must have exactly one value.") distance[unit] = float(distance[unit][0]) if point and distance: applicable_filters = { "dwithin": { "field": self.backend.point_field, "point": point, "distance": self.D(**distance) }, "distance": { "field": self.backend.point_field, "point": point } } return applicable_filters
python
def build_query(self, **filters): """ Build queries for geo spatial filtering. Expected query parameters are: - a `unit=value` parameter where the unit is a valid UNIT in the `django.contrib.gis.measure.Distance` class. - `from` which must be a comma separated latitude and longitude. Example query: /api/v1/search/?km=10&from=59.744076,10.152045 Will perform a `dwithin` query within 10 km from the point with latitude 59.744076 and longitude 10.152045. """ applicable_filters = None filters = dict((k, filters[k]) for k in chain(self.D.UNITS.keys(), [constants.DRF_HAYSTACK_SPATIAL_QUERY_PARAM]) if k in filters) distance = dict((k, v) for k, v in filters.items() if k in self.D.UNITS.keys()) try: latitude, longitude = map(float, self.tokenize(filters[constants.DRF_HAYSTACK_SPATIAL_QUERY_PARAM], self.view.lookup_sep)) point = self.Point(longitude, latitude, srid=constants.GEO_SRID) except ValueError: raise ValueError("Cannot convert `from=latitude,longitude` query parameter to " "float values. Make sure to provide numerical values only!") except KeyError: # If the user has not provided any `from` query string parameter, # just return. pass else: for unit in distance.keys(): if not len(distance[unit]) == 1: raise ValueError("Each unit must have exactly one value.") distance[unit] = float(distance[unit][0]) if point and distance: applicable_filters = { "dwithin": { "field": self.backend.point_field, "point": point, "distance": self.D(**distance) }, "distance": { "field": self.backend.point_field, "point": point } } return applicable_filters
[ "def", "build_query", "(", "self", ",", "*", "*", "filters", ")", ":", "applicable_filters", "=", "None", "filters", "=", "dict", "(", "(", "k", ",", "filters", "[", "k", "]", ")", "for", "k", "in", "chain", "(", "self", ".", "D", ".", "UNITS", ".", "keys", "(", ")", ",", "[", "constants", ".", "DRF_HAYSTACK_SPATIAL_QUERY_PARAM", "]", ")", "if", "k", "in", "filters", ")", "distance", "=", "dict", "(", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "filters", ".", "items", "(", ")", "if", "k", "in", "self", ".", "D", ".", "UNITS", ".", "keys", "(", ")", ")", "try", ":", "latitude", ",", "longitude", "=", "map", "(", "float", ",", "self", ".", "tokenize", "(", "filters", "[", "constants", ".", "DRF_HAYSTACK_SPATIAL_QUERY_PARAM", "]", ",", "self", ".", "view", ".", "lookup_sep", ")", ")", "point", "=", "self", ".", "Point", "(", "longitude", ",", "latitude", ",", "srid", "=", "constants", ".", "GEO_SRID", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "\"Cannot convert `from=latitude,longitude` query parameter to \"", "\"float values. Make sure to provide numerical values only!\"", ")", "except", "KeyError", ":", "# If the user has not provided any `from` query string parameter,", "# just return.", "pass", "else", ":", "for", "unit", "in", "distance", ".", "keys", "(", ")", ":", "if", "not", "len", "(", "distance", "[", "unit", "]", ")", "==", "1", ":", "raise", "ValueError", "(", "\"Each unit must have exactly one value.\"", ")", "distance", "[", "unit", "]", "=", "float", "(", "distance", "[", "unit", "]", "[", "0", "]", ")", "if", "point", "and", "distance", ":", "applicable_filters", "=", "{", "\"dwithin\"", ":", "{", "\"field\"", ":", "self", ".", "backend", ".", "point_field", ",", "\"point\"", ":", "point", ",", "\"distance\"", ":", "self", ".", "D", "(", "*", "*", "distance", ")", "}", ",", "\"distance\"", ":", "{", "\"field\"", ":", "self", ".", "backend", ".", "point_field", ",", "\"point\"", ":", "point", "}", "}", "return", "applicable_filters" ]
Build queries for geo spatial filtering. Expected query parameters are: - a `unit=value` parameter where the unit is a valid UNIT in the `django.contrib.gis.measure.Distance` class. - `from` which must be a comma separated latitude and longitude. Example query: /api/v1/search/?km=10&from=59.744076,10.152045 Will perform a `dwithin` query within 10 km from the point with latitude 59.744076 and longitude 10.152045.
[ "Build", "queries", "for", "geo", "spatial", "filtering", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/query.py#L266-L318
train
inonit/drf-haystack
drf_haystack/utils.py
merge_dict
def merge_dict(a, b): """ Recursively merges and returns dict a with dict b. Any list values will be combined and returned sorted. :param a: dictionary object :param b: dictionary object :return: merged dictionary object """ if not isinstance(b, dict): return b result = deepcopy(a) for key, val in six.iteritems(b): if key in result and isinstance(result[key], dict): result[key] = merge_dict(result[key], val) elif key in result and isinstance(result[key], list): result[key] = sorted(list(set(val) | set(result[key]))) else: result[key] = deepcopy(val) return result
python
def merge_dict(a, b): """ Recursively merges and returns dict a with dict b. Any list values will be combined and returned sorted. :param a: dictionary object :param b: dictionary object :return: merged dictionary object """ if not isinstance(b, dict): return b result = deepcopy(a) for key, val in six.iteritems(b): if key in result and isinstance(result[key], dict): result[key] = merge_dict(result[key], val) elif key in result and isinstance(result[key], list): result[key] = sorted(list(set(val) | set(result[key]))) else: result[key] = deepcopy(val) return result
[ "def", "merge_dict", "(", "a", ",", "b", ")", ":", "if", "not", "isinstance", "(", "b", ",", "dict", ")", ":", "return", "b", "result", "=", "deepcopy", "(", "a", ")", "for", "key", ",", "val", "in", "six", ".", "iteritems", "(", "b", ")", ":", "if", "key", "in", "result", "and", "isinstance", "(", "result", "[", "key", "]", ",", "dict", ")", ":", "result", "[", "key", "]", "=", "merge_dict", "(", "result", "[", "key", "]", ",", "val", ")", "elif", "key", "in", "result", "and", "isinstance", "(", "result", "[", "key", "]", ",", "list", ")", ":", "result", "[", "key", "]", "=", "sorted", "(", "list", "(", "set", "(", "val", ")", "|", "set", "(", "result", "[", "key", "]", ")", ")", ")", "else", ":", "result", "[", "key", "]", "=", "deepcopy", "(", "val", ")", "return", "result" ]
Recursively merges and returns dict a with dict b. Any list values will be combined and returned sorted. :param a: dictionary object :param b: dictionary object :return: merged dictionary object
[ "Recursively", "merges", "and", "returns", "dict", "a", "with", "dict", "b", ".", "Any", "list", "values", "will", "be", "combined", "and", "returned", "sorted", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/utils.py#L9-L31
train
inonit/drf-haystack
drf_haystack/generics.py
HaystackGenericAPIView.get_queryset
def get_queryset(self, index_models=[]): """ Get the list of items for this view. Returns ``self.queryset`` if defined and is a ``self.object_class`` instance. @:param index_models: override `self.index_models` """ if self.queryset is not None and isinstance(self.queryset, self.object_class): queryset = self.queryset.all() else: queryset = self.object_class()._clone() if len(index_models): queryset = queryset.models(*index_models) elif len(self.index_models): queryset = queryset.models(*self.index_models) return queryset
python
def get_queryset(self, index_models=[]): """ Get the list of items for this view. Returns ``self.queryset`` if defined and is a ``self.object_class`` instance. @:param index_models: override `self.index_models` """ if self.queryset is not None and isinstance(self.queryset, self.object_class): queryset = self.queryset.all() else: queryset = self.object_class()._clone() if len(index_models): queryset = queryset.models(*index_models) elif len(self.index_models): queryset = queryset.models(*self.index_models) return queryset
[ "def", "get_queryset", "(", "self", ",", "index_models", "=", "[", "]", ")", ":", "if", "self", ".", "queryset", "is", "not", "None", "and", "isinstance", "(", "self", ".", "queryset", ",", "self", ".", "object_class", ")", ":", "queryset", "=", "self", ".", "queryset", ".", "all", "(", ")", "else", ":", "queryset", "=", "self", ".", "object_class", "(", ")", ".", "_clone", "(", ")", "if", "len", "(", "index_models", ")", ":", "queryset", "=", "queryset", ".", "models", "(", "*", "index_models", ")", "elif", "len", "(", "self", ".", "index_models", ")", ":", "queryset", "=", "queryset", ".", "models", "(", "*", "self", ".", "index_models", ")", "return", "queryset" ]
Get the list of items for this view. Returns ``self.queryset`` if defined and is a ``self.object_class`` instance. @:param index_models: override `self.index_models`
[ "Get", "the", "list", "of", "items", "for", "this", "view", ".", "Returns", "self", ".", "queryset", "if", "defined", "and", "is", "a", "self", ".", "object_class", "instance", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/generics.py#L40-L56
train
inonit/drf-haystack
drf_haystack/generics.py
HaystackGenericAPIView.get_object
def get_object(self): """ Fetch a single document from the data store according to whatever unique identifier is available for that document in the SearchIndex. In cases where the view has multiple ``index_models``, add a ``model`` query parameter containing a single `app_label.model` name to the request in order to override which model to include in the SearchQuerySet. Example: /api/v1/search/42/?model=myapp.person """ queryset = self.get_queryset() if "model" in self.request.query_params: try: app_label, model = map(six.text_type.lower, self.request.query_params["model"].split(".", 1)) ctype = ContentType.objects.get(app_label=app_label, model=model) queryset = self.get_queryset(index_models=[ctype.model_class()]) except (ValueError, ContentType.DoesNotExist): raise Http404("Could not find any models matching '%s'. Make sure to use a valid " "'app_label.model' name for the 'model' query parameter." % self.request.query_params["model"]) lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field if lookup_url_kwarg not in self.kwargs: raise AttributeError( "Expected view %s to be called with a URL keyword argument " "named '%s'. Fix your URL conf, or set the `.lookup_field` " "attribute on the view correctly." % (self.__class__.__name__, lookup_url_kwarg) ) queryset = queryset.filter(self.query_object((self.document_uid_field, self.kwargs[lookup_url_kwarg]))) count = queryset.count() if count == 1: return queryset[0] elif count > 1: raise Http404("Multiple results matches the given query. Expected a single result.") raise Http404("No result matches the given query.")
python
def get_object(self): """ Fetch a single document from the data store according to whatever unique identifier is available for that document in the SearchIndex. In cases where the view has multiple ``index_models``, add a ``model`` query parameter containing a single `app_label.model` name to the request in order to override which model to include in the SearchQuerySet. Example: /api/v1/search/42/?model=myapp.person """ queryset = self.get_queryset() if "model" in self.request.query_params: try: app_label, model = map(six.text_type.lower, self.request.query_params["model"].split(".", 1)) ctype = ContentType.objects.get(app_label=app_label, model=model) queryset = self.get_queryset(index_models=[ctype.model_class()]) except (ValueError, ContentType.DoesNotExist): raise Http404("Could not find any models matching '%s'. Make sure to use a valid " "'app_label.model' name for the 'model' query parameter." % self.request.query_params["model"]) lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field if lookup_url_kwarg not in self.kwargs: raise AttributeError( "Expected view %s to be called with a URL keyword argument " "named '%s'. Fix your URL conf, or set the `.lookup_field` " "attribute on the view correctly." % (self.__class__.__name__, lookup_url_kwarg) ) queryset = queryset.filter(self.query_object((self.document_uid_field, self.kwargs[lookup_url_kwarg]))) count = queryset.count() if count == 1: return queryset[0] elif count > 1: raise Http404("Multiple results matches the given query. Expected a single result.") raise Http404("No result matches the given query.")
[ "def", "get_object", "(", "self", ")", ":", "queryset", "=", "self", ".", "get_queryset", "(", ")", "if", "\"model\"", "in", "self", ".", "request", ".", "query_params", ":", "try", ":", "app_label", ",", "model", "=", "map", "(", "six", ".", "text_type", ".", "lower", ",", "self", ".", "request", ".", "query_params", "[", "\"model\"", "]", ".", "split", "(", "\".\"", ",", "1", ")", ")", "ctype", "=", "ContentType", ".", "objects", ".", "get", "(", "app_label", "=", "app_label", ",", "model", "=", "model", ")", "queryset", "=", "self", ".", "get_queryset", "(", "index_models", "=", "[", "ctype", ".", "model_class", "(", ")", "]", ")", "except", "(", "ValueError", ",", "ContentType", ".", "DoesNotExist", ")", ":", "raise", "Http404", "(", "\"Could not find any models matching '%s'. Make sure to use a valid \"", "\"'app_label.model' name for the 'model' query parameter.\"", "%", "self", ".", "request", ".", "query_params", "[", "\"model\"", "]", ")", "lookup_url_kwarg", "=", "self", ".", "lookup_url_kwarg", "or", "self", ".", "lookup_field", "if", "lookup_url_kwarg", "not", "in", "self", ".", "kwargs", ":", "raise", "AttributeError", "(", "\"Expected view %s to be called with a URL keyword argument \"", "\"named '%s'. Fix your URL conf, or set the `.lookup_field` \"", "\"attribute on the view correctly.\"", "%", "(", "self", ".", "__class__", ".", "__name__", ",", "lookup_url_kwarg", ")", ")", "queryset", "=", "queryset", ".", "filter", "(", "self", ".", "query_object", "(", "(", "self", ".", "document_uid_field", ",", "self", ".", "kwargs", "[", "lookup_url_kwarg", "]", ")", ")", ")", "count", "=", "queryset", ".", "count", "(", ")", "if", "count", "==", "1", ":", "return", "queryset", "[", "0", "]", "elif", "count", ">", "1", ":", "raise", "Http404", "(", "\"Multiple results matches the given query. Expected a single result.\"", ")", "raise", "Http404", "(", "\"No result matches the given query.\"", ")" ]
Fetch a single document from the data store according to whatever unique identifier is available for that document in the SearchIndex. In cases where the view has multiple ``index_models``, add a ``model`` query parameter containing a single `app_label.model` name to the request in order to override which model to include in the SearchQuerySet. Example: /api/v1/search/42/?model=myapp.person
[ "Fetch", "a", "single", "document", "from", "the", "data", "store", "according", "to", "whatever", "unique", "identifier", "is", "available", "for", "that", "document", "in", "the", "SearchIndex", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/generics.py#L58-L95
train
inonit/drf-haystack
drf_haystack/mixins.py
MoreLikeThisMixin.more_like_this
def more_like_this(self, request, pk=None): """ Sets up a detail route for ``more-like-this`` results. Note that you'll need backend support in order to take advantage of this. This will add ie. ^search/{pk}/more-like-this/$ to your existing ^search pattern. """ obj = self.get_object().object queryset = self.filter_queryset(self.get_queryset()).more_like_this(obj) page = self.paginate_queryset(queryset) if page is not None: serializer = self.get_serializer(page, many=True) return self.get_paginated_response(serializer.data) serializer = self.get_serializer(queryset, many=True) return Response(serializer.data)
python
def more_like_this(self, request, pk=None): """ Sets up a detail route for ``more-like-this`` results. Note that you'll need backend support in order to take advantage of this. This will add ie. ^search/{pk}/more-like-this/$ to your existing ^search pattern. """ obj = self.get_object().object queryset = self.filter_queryset(self.get_queryset()).more_like_this(obj) page = self.paginate_queryset(queryset) if page is not None: serializer = self.get_serializer(page, many=True) return self.get_paginated_response(serializer.data) serializer = self.get_serializer(queryset, many=True) return Response(serializer.data)
[ "def", "more_like_this", "(", "self", ",", "request", ",", "pk", "=", "None", ")", ":", "obj", "=", "self", ".", "get_object", "(", ")", ".", "object", "queryset", "=", "self", ".", "filter_queryset", "(", "self", ".", "get_queryset", "(", ")", ")", ".", "more_like_this", "(", "obj", ")", "page", "=", "self", ".", "paginate_queryset", "(", "queryset", ")", "if", "page", "is", "not", "None", ":", "serializer", "=", "self", ".", "get_serializer", "(", "page", ",", "many", "=", "True", ")", "return", "self", ".", "get_paginated_response", "(", "serializer", ".", "data", ")", "serializer", "=", "self", ".", "get_serializer", "(", "queryset", ",", "many", "=", "True", ")", "return", "Response", "(", "serializer", ".", "data", ")" ]
Sets up a detail route for ``more-like-this`` results. Note that you'll need backend support in order to take advantage of this. This will add ie. ^search/{pk}/more-like-this/$ to your existing ^search pattern.
[ "Sets", "up", "a", "detail", "route", "for", "more", "-", "like", "-", "this", "results", ".", "Note", "that", "you", "ll", "need", "backend", "support", "in", "order", "to", "take", "advantage", "of", "this", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/mixins.py#L17-L33
train
inonit/drf-haystack
drf_haystack/mixins.py
FacetMixin.filter_facet_queryset
def filter_facet_queryset(self, queryset): """ Given a search queryset, filter it with whichever facet filter backends in use. """ for backend in list(self.facet_filter_backends): queryset = backend().filter_queryset(self.request, queryset, self) if self.load_all: queryset = queryset.load_all() return queryset
python
def filter_facet_queryset(self, queryset): """ Given a search queryset, filter it with whichever facet filter backends in use. """ for backend in list(self.facet_filter_backends): queryset = backend().filter_queryset(self.request, queryset, self) if self.load_all: queryset = queryset.load_all() return queryset
[ "def", "filter_facet_queryset", "(", "self", ",", "queryset", ")", ":", "for", "backend", "in", "list", "(", "self", ".", "facet_filter_backends", ")", ":", "queryset", "=", "backend", "(", ")", ".", "filter_queryset", "(", "self", ".", "request", ",", "queryset", ",", "self", ")", "if", "self", ".", "load_all", ":", "queryset", "=", "queryset", ".", "load_all", "(", ")", "return", "queryset" ]
Given a search queryset, filter it with whichever facet filter backends in use.
[ "Given", "a", "search", "queryset", "filter", "it", "with", "whichever", "facet", "filter", "backends", "in", "use", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/mixins.py#L66-L77
train
inonit/drf-haystack
drf_haystack/mixins.py
FacetMixin.get_facet_serializer
def get_facet_serializer(self, *args, **kwargs): """ Return the facet serializer instance that should be used for serializing faceted output. """ assert "objects" in kwargs, "`objects` is a required argument to `get_facet_serializer()`" facet_serializer_class = self.get_facet_serializer_class() kwargs["context"] = self.get_serializer_context() kwargs["context"].update({ "objects": kwargs.pop("objects"), "facet_query_params_text": self.facet_query_params_text, }) return facet_serializer_class(*args, **kwargs)
python
def get_facet_serializer(self, *args, **kwargs): """ Return the facet serializer instance that should be used for serializing faceted output. """ assert "objects" in kwargs, "`objects` is a required argument to `get_facet_serializer()`" facet_serializer_class = self.get_facet_serializer_class() kwargs["context"] = self.get_serializer_context() kwargs["context"].update({ "objects": kwargs.pop("objects"), "facet_query_params_text": self.facet_query_params_text, }) return facet_serializer_class(*args, **kwargs)
[ "def", "get_facet_serializer", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "assert", "\"objects\"", "in", "kwargs", ",", "\"`objects` is a required argument to `get_facet_serializer()`\"", "facet_serializer_class", "=", "self", ".", "get_facet_serializer_class", "(", ")", "kwargs", "[", "\"context\"", "]", "=", "self", ".", "get_serializer_context", "(", ")", "kwargs", "[", "\"context\"", "]", ".", "update", "(", "{", "\"objects\"", ":", "kwargs", ".", "pop", "(", "\"objects\"", ")", ",", "\"facet_query_params_text\"", ":", "self", ".", "facet_query_params_text", ",", "}", ")", "return", "facet_serializer_class", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]
Return the facet serializer instance that should be used for serializing faceted output.
[ "Return", "the", "facet", "serializer", "instance", "that", "should", "be", "used", "for", "serializing", "faceted", "output", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/mixins.py#L79-L92
train
inonit/drf-haystack
drf_haystack/mixins.py
FacetMixin.get_facet_serializer_class
def get_facet_serializer_class(self): """ Return the class to use for serializing facets. Defaults to using ``self.facet_serializer_class``. """ if self.facet_serializer_class is None: raise AttributeError( "%(cls)s should either include a `facet_serializer_class` attribute, " "or override %(cls)s.get_facet_serializer_class() method." % {"cls": self.__class__.__name__} ) return self.facet_serializer_class
python
def get_facet_serializer_class(self): """ Return the class to use for serializing facets. Defaults to using ``self.facet_serializer_class``. """ if self.facet_serializer_class is None: raise AttributeError( "%(cls)s should either include a `facet_serializer_class` attribute, " "or override %(cls)s.get_facet_serializer_class() method." % {"cls": self.__class__.__name__} ) return self.facet_serializer_class
[ "def", "get_facet_serializer_class", "(", "self", ")", ":", "if", "self", ".", "facet_serializer_class", "is", "None", ":", "raise", "AttributeError", "(", "\"%(cls)s should either include a `facet_serializer_class` attribute, \"", "\"or override %(cls)s.get_facet_serializer_class() method.\"", "%", "{", "\"cls\"", ":", "self", ".", "__class__", ".", "__name__", "}", ")", "return", "self", ".", "facet_serializer_class" ]
Return the class to use for serializing facets. Defaults to using ``self.facet_serializer_class``.
[ "Return", "the", "class", "to", "use", "for", "serializing", "facets", ".", "Defaults", "to", "using", "self", ".", "facet_serializer_class", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/mixins.py#L94-L105
train
inonit/drf-haystack
drf_haystack/mixins.py
FacetMixin.get_facet_objects_serializer
def get_facet_objects_serializer(self, *args, **kwargs): """ Return the serializer instance which should be used for serializing faceted objects. """ facet_objects_serializer_class = self.get_facet_objects_serializer_class() kwargs["context"] = self.get_serializer_context() return facet_objects_serializer_class(*args, **kwargs)
python
def get_facet_objects_serializer(self, *args, **kwargs): """ Return the serializer instance which should be used for serializing faceted objects. """ facet_objects_serializer_class = self.get_facet_objects_serializer_class() kwargs["context"] = self.get_serializer_context() return facet_objects_serializer_class(*args, **kwargs)
[ "def", "get_facet_objects_serializer", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "facet_objects_serializer_class", "=", "self", ".", "get_facet_objects_serializer_class", "(", ")", "kwargs", "[", "\"context\"", "]", "=", "self", ".", "get_serializer_context", "(", ")", "return", "facet_objects_serializer_class", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]
Return the serializer instance which should be used for serializing faceted objects.
[ "Return", "the", "serializer", "instance", "which", "should", "be", "used", "for", "serializing", "faceted", "objects", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/mixins.py#L107-L114
train
inonit/drf-haystack
drf_haystack/fields.py
DRFHaystackFieldMixin.bind
def bind(self, field_name, parent): """ Initializes the field name and parent for the field instance. Called when a field is added to the parent serializer instance. Taken from DRF and modified to support drf_haystack multiple index functionality. """ # In order to enforce a consistent style, we error if a redundant # 'source' argument has been used. For example: # my_field = serializer.CharField(source='my_field') assert self.source != field_name, ( "It is redundant to specify `source='%s'` on field '%s' in " "serializer '%s', because it is the same as the field name. " "Remove the `source` keyword argument." % (field_name, self.__class__.__name__, parent.__class__.__name__) ) self.field_name = field_name self.parent = parent # `self.label` should default to being based on the field name. if self.label is None: self.label = field_name.replace('_', ' ').capitalize() # self.source should default to being the same as the field name. if self.source is None: self.source = self.convert_field_name(field_name) # self.source_attrs is a list of attributes that need to be looked up # when serializing the instance, or populating the validated data. if self.source == '*': self.source_attrs = [] else: self.source_attrs = self.source.split('.')
python
def bind(self, field_name, parent): """ Initializes the field name and parent for the field instance. Called when a field is added to the parent serializer instance. Taken from DRF and modified to support drf_haystack multiple index functionality. """ # In order to enforce a consistent style, we error if a redundant # 'source' argument has been used. For example: # my_field = serializer.CharField(source='my_field') assert self.source != field_name, ( "It is redundant to specify `source='%s'` on field '%s' in " "serializer '%s', because it is the same as the field name. " "Remove the `source` keyword argument." % (field_name, self.__class__.__name__, parent.__class__.__name__) ) self.field_name = field_name self.parent = parent # `self.label` should default to being based on the field name. if self.label is None: self.label = field_name.replace('_', ' ').capitalize() # self.source should default to being the same as the field name. if self.source is None: self.source = self.convert_field_name(field_name) # self.source_attrs is a list of attributes that need to be looked up # when serializing the instance, or populating the validated data. if self.source == '*': self.source_attrs = [] else: self.source_attrs = self.source.split('.')
[ "def", "bind", "(", "self", ",", "field_name", ",", "parent", ")", ":", "# In order to enforce a consistent style, we error if a redundant", "# 'source' argument has been used. For example:", "# my_field = serializer.CharField(source='my_field')", "assert", "self", ".", "source", "!=", "field_name", ",", "(", "\"It is redundant to specify `source='%s'` on field '%s' in \"", "\"serializer '%s', because it is the same as the field name. \"", "\"Remove the `source` keyword argument.\"", "%", "(", "field_name", ",", "self", ".", "__class__", ".", "__name__", ",", "parent", ".", "__class__", ".", "__name__", ")", ")", "self", ".", "field_name", "=", "field_name", "self", ".", "parent", "=", "parent", "# `self.label` should default to being based on the field name.", "if", "self", ".", "label", "is", "None", ":", "self", ".", "label", "=", "field_name", ".", "replace", "(", "'_'", ",", "' '", ")", ".", "capitalize", "(", ")", "# self.source should default to being the same as the field name.", "if", "self", ".", "source", "is", "None", ":", "self", ".", "source", "=", "self", ".", "convert_field_name", "(", "field_name", ")", "# self.source_attrs is a list of attributes that need to be looked up", "# when serializing the instance, or populating the validated data.", "if", "self", ".", "source", "==", "'*'", ":", "self", ".", "source_attrs", "=", "[", "]", "else", ":", "self", ".", "source_attrs", "=", "self", ".", "source", ".", "split", "(", "'.'", ")" ]
Initializes the field name and parent for the field instance. Called when a field is added to the parent serializer instance. Taken from DRF and modified to support drf_haystack multiple index functionality.
[ "Initializes", "the", "field", "name", "and", "parent", "for", "the", "field", "instance", ".", "Called", "when", "a", "field", "is", "added", "to", "the", "parent", "serializer", "instance", ".", "Taken", "from", "DRF", "and", "modified", "to", "support", "drf_haystack", "multiple", "index", "functionality", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/fields.py#L16-L50
train
inonit/drf-haystack
drf_haystack/serializers.py
HaystackSerializer._get_default_field_kwargs
def _get_default_field_kwargs(model, field): """ Get the required attributes from the model field in order to instantiate a REST Framework serializer field. """ kwargs = {} try: field_name = field.model_attr or field.index_fieldname model_field = model._meta.get_field(field_name) kwargs.update(get_field_kwargs(field_name, model_field)) # Remove stuff we don't care about! delete_attrs = [ "allow_blank", "choices", "model_field", "allow_unicode", ] for attr in delete_attrs: if attr in kwargs: del kwargs[attr] except FieldDoesNotExist: pass return kwargs
python
def _get_default_field_kwargs(model, field): """ Get the required attributes from the model field in order to instantiate a REST Framework serializer field. """ kwargs = {} try: field_name = field.model_attr or field.index_fieldname model_field = model._meta.get_field(field_name) kwargs.update(get_field_kwargs(field_name, model_field)) # Remove stuff we don't care about! delete_attrs = [ "allow_blank", "choices", "model_field", "allow_unicode", ] for attr in delete_attrs: if attr in kwargs: del kwargs[attr] except FieldDoesNotExist: pass return kwargs
[ "def", "_get_default_field_kwargs", "(", "model", ",", "field", ")", ":", "kwargs", "=", "{", "}", "try", ":", "field_name", "=", "field", ".", "model_attr", "or", "field", ".", "index_fieldname", "model_field", "=", "model", ".", "_meta", ".", "get_field", "(", "field_name", ")", "kwargs", ".", "update", "(", "get_field_kwargs", "(", "field_name", ",", "model_field", ")", ")", "# Remove stuff we don't care about!", "delete_attrs", "=", "[", "\"allow_blank\"", ",", "\"choices\"", ",", "\"model_field\"", ",", "\"allow_unicode\"", ",", "]", "for", "attr", "in", "delete_attrs", ":", "if", "attr", "in", "kwargs", ":", "del", "kwargs", "[", "attr", "]", "except", "FieldDoesNotExist", ":", "pass", "return", "kwargs" ]
Get the required attributes from the model field in order to instantiate a REST Framework serializer field.
[ "Get", "the", "required", "attributes", "from", "the", "model", "field", "in", "order", "to", "instantiate", "a", "REST", "Framework", "serializer", "field", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L124-L148
train
inonit/drf-haystack
drf_haystack/serializers.py
HaystackSerializer._get_index_class_name
def _get_index_class_name(self, index_cls): """ Converts in index model class to a name suitable for use as a field name prefix. A user may optionally specify custom aliases via an 'index_aliases' attribute on the Meta class """ cls_name = index_cls.__name__ aliases = self.Meta.index_aliases return aliases.get(cls_name, cls_name.split('.')[-1])
python
def _get_index_class_name(self, index_cls): """ Converts in index model class to a name suitable for use as a field name prefix. A user may optionally specify custom aliases via an 'index_aliases' attribute on the Meta class """ cls_name = index_cls.__name__ aliases = self.Meta.index_aliases return aliases.get(cls_name, cls_name.split('.')[-1])
[ "def", "_get_index_class_name", "(", "self", ",", "index_cls", ")", ":", "cls_name", "=", "index_cls", ".", "__name__", "aliases", "=", "self", ".", "Meta", ".", "index_aliases", "return", "aliases", ".", "get", "(", "cls_name", ",", "cls_name", ".", "split", "(", "'.'", ")", "[", "-", "1", "]", ")" ]
Converts in index model class to a name suitable for use as a field name prefix. A user may optionally specify custom aliases via an 'index_aliases' attribute on the Meta class
[ "Converts", "in", "index", "model", "class", "to", "a", "name", "suitable", "for", "use", "as", "a", "field", "name", "prefix", ".", "A", "user", "may", "optionally", "specify", "custom", "aliases", "via", "an", "index_aliases", "attribute", "on", "the", "Meta", "class" ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L156-L163
train
inonit/drf-haystack
drf_haystack/serializers.py
HaystackSerializer.get_fields
def get_fields(self): """ Get the required fields for serializing the result. """ fields = self.Meta.fields exclude = self.Meta.exclude ignore_fields = self.Meta.ignore_fields indices = self.Meta.index_classes declared_fields = copy.deepcopy(self._declared_fields) prefix_field_names = len(indices) > 1 field_mapping = OrderedDict() # overlapping fields on multiple indices is supported by internally prefixing the field # names with the index class to which they belong or, optionally, a user-provided alias # for the index. for index_cls in self.Meta.index_classes: prefix = "" if prefix_field_names: prefix = "_%s__" % self._get_index_class_name(index_cls) for field_name, field_type in six.iteritems(index_cls.fields): orig_name = field_name field_name = "%s%s" % (prefix, field_name) # Don't use this field if it is in `ignore_fields` if orig_name in ignore_fields or field_name in ignore_fields: continue # When fields to include are decided by `exclude` if exclude: if orig_name in exclude or field_name in exclude: continue # When fields to include are decided by `fields` if fields: if orig_name not in fields and field_name not in fields: continue # Look up the field attributes on the current index model, # in order to correctly instantiate the serializer field. model = index_cls().get_model() kwargs = self._get_default_field_kwargs(model, field_type) kwargs['prefix_field_names'] = prefix_field_names field_mapping[field_name] = self._field_mapping[field_type](**kwargs) # Add any explicitly declared fields. They *will* override any index fields # in case of naming collision!. if declared_fields: for field_name in declared_fields: field_mapping[field_name] = declared_fields[field_name] return field_mapping
python
def get_fields(self): """ Get the required fields for serializing the result. """ fields = self.Meta.fields exclude = self.Meta.exclude ignore_fields = self.Meta.ignore_fields indices = self.Meta.index_classes declared_fields = copy.deepcopy(self._declared_fields) prefix_field_names = len(indices) > 1 field_mapping = OrderedDict() # overlapping fields on multiple indices is supported by internally prefixing the field # names with the index class to which they belong or, optionally, a user-provided alias # for the index. for index_cls in self.Meta.index_classes: prefix = "" if prefix_field_names: prefix = "_%s__" % self._get_index_class_name(index_cls) for field_name, field_type in six.iteritems(index_cls.fields): orig_name = field_name field_name = "%s%s" % (prefix, field_name) # Don't use this field if it is in `ignore_fields` if orig_name in ignore_fields or field_name in ignore_fields: continue # When fields to include are decided by `exclude` if exclude: if orig_name in exclude or field_name in exclude: continue # When fields to include are decided by `fields` if fields: if orig_name not in fields and field_name not in fields: continue # Look up the field attributes on the current index model, # in order to correctly instantiate the serializer field. model = index_cls().get_model() kwargs = self._get_default_field_kwargs(model, field_type) kwargs['prefix_field_names'] = prefix_field_names field_mapping[field_name] = self._field_mapping[field_type](**kwargs) # Add any explicitly declared fields. They *will* override any index fields # in case of naming collision!. if declared_fields: for field_name in declared_fields: field_mapping[field_name] = declared_fields[field_name] return field_mapping
[ "def", "get_fields", "(", "self", ")", ":", "fields", "=", "self", ".", "Meta", ".", "fields", "exclude", "=", "self", ".", "Meta", ".", "exclude", "ignore_fields", "=", "self", ".", "Meta", ".", "ignore_fields", "indices", "=", "self", ".", "Meta", ".", "index_classes", "declared_fields", "=", "copy", ".", "deepcopy", "(", "self", ".", "_declared_fields", ")", "prefix_field_names", "=", "len", "(", "indices", ")", ">", "1", "field_mapping", "=", "OrderedDict", "(", ")", "# overlapping fields on multiple indices is supported by internally prefixing the field", "# names with the index class to which they belong or, optionally, a user-provided alias", "# for the index.", "for", "index_cls", "in", "self", ".", "Meta", ".", "index_classes", ":", "prefix", "=", "\"\"", "if", "prefix_field_names", ":", "prefix", "=", "\"_%s__\"", "%", "self", ".", "_get_index_class_name", "(", "index_cls", ")", "for", "field_name", ",", "field_type", "in", "six", ".", "iteritems", "(", "index_cls", ".", "fields", ")", ":", "orig_name", "=", "field_name", "field_name", "=", "\"%s%s\"", "%", "(", "prefix", ",", "field_name", ")", "# Don't use this field if it is in `ignore_fields`", "if", "orig_name", "in", "ignore_fields", "or", "field_name", "in", "ignore_fields", ":", "continue", "# When fields to include are decided by `exclude`", "if", "exclude", ":", "if", "orig_name", "in", "exclude", "or", "field_name", "in", "exclude", ":", "continue", "# When fields to include are decided by `fields`", "if", "fields", ":", "if", "orig_name", "not", "in", "fields", "and", "field_name", "not", "in", "fields", ":", "continue", "# Look up the field attributes on the current index model,", "# in order to correctly instantiate the serializer field.", "model", "=", "index_cls", "(", ")", ".", "get_model", "(", ")", "kwargs", "=", "self", ".", "_get_default_field_kwargs", "(", "model", ",", "field_type", ")", "kwargs", "[", "'prefix_field_names'", "]", "=", "prefix_field_names", "field_mapping", "[", "field_name", "]", "=", "self", ".", "_field_mapping", "[", "field_type", "]", "(", "*", "*", "kwargs", ")", "# Add any explicitly declared fields. They *will* override any index fields", "# in case of naming collision!.", "if", "declared_fields", ":", "for", "field_name", "in", "declared_fields", ":", "field_mapping", "[", "field_name", "]", "=", "declared_fields", "[", "field_name", "]", "return", "field_mapping" ]
Get the required fields for serializing the result.
[ "Get", "the", "required", "fields", "for", "serializing", "the", "result", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L165-L214
train
inonit/drf-haystack
drf_haystack/serializers.py
HaystackSerializer.to_representation
def to_representation(self, instance): """ If we have a serializer mapping, use that. Otherwise, use standard serializer behavior Since we might be dealing with multiple indexes, some fields might not be valid for all results. Do not render the fields which don't belong to the search result. """ if self.Meta.serializers: ret = self.multi_serializer_representation(instance) else: ret = super(HaystackSerializer, self).to_representation(instance) prefix_field_names = len(getattr(self.Meta, "index_classes")) > 1 current_index = self._get_index_class_name(type(instance.searchindex)) for field in self.fields.keys(): # handle declared field value methods on serializer value_method = getattr(self, "get_{}".format(field), None) if value_method and callable(value_method): ret[field] = value_method() # now convert namespaced field names orig_field = field if prefix_field_names: parts = field.split("__") if len(parts) > 1: index = parts[0][1:] # trim the preceding '_' field = parts[1] if index == current_index: ret[field] = ret[orig_field] del ret[orig_field] elif field not in chain(instance.searchindex.fields.keys(), self._declared_fields.keys()): del ret[orig_field] # include the highlighted field in either case if getattr(instance, "highlighted", None): ret["highlighted"] = instance.highlighted[0] return ret
python
def to_representation(self, instance): """ If we have a serializer mapping, use that. Otherwise, use standard serializer behavior Since we might be dealing with multiple indexes, some fields might not be valid for all results. Do not render the fields which don't belong to the search result. """ if self.Meta.serializers: ret = self.multi_serializer_representation(instance) else: ret = super(HaystackSerializer, self).to_representation(instance) prefix_field_names = len(getattr(self.Meta, "index_classes")) > 1 current_index = self._get_index_class_name(type(instance.searchindex)) for field in self.fields.keys(): # handle declared field value methods on serializer value_method = getattr(self, "get_{}".format(field), None) if value_method and callable(value_method): ret[field] = value_method() # now convert namespaced field names orig_field = field if prefix_field_names: parts = field.split("__") if len(parts) > 1: index = parts[0][1:] # trim the preceding '_' field = parts[1] if index == current_index: ret[field] = ret[orig_field] del ret[orig_field] elif field not in chain(instance.searchindex.fields.keys(), self._declared_fields.keys()): del ret[orig_field] # include the highlighted field in either case if getattr(instance, "highlighted", None): ret["highlighted"] = instance.highlighted[0] return ret
[ "def", "to_representation", "(", "self", ",", "instance", ")", ":", "if", "self", ".", "Meta", ".", "serializers", ":", "ret", "=", "self", ".", "multi_serializer_representation", "(", "instance", ")", "else", ":", "ret", "=", "super", "(", "HaystackSerializer", ",", "self", ")", ".", "to_representation", "(", "instance", ")", "prefix_field_names", "=", "len", "(", "getattr", "(", "self", ".", "Meta", ",", "\"index_classes\"", ")", ")", ">", "1", "current_index", "=", "self", ".", "_get_index_class_name", "(", "type", "(", "instance", ".", "searchindex", ")", ")", "for", "field", "in", "self", ".", "fields", ".", "keys", "(", ")", ":", "# handle declared field value methods on serializer", "value_method", "=", "getattr", "(", "self", ",", "\"get_{}\"", ".", "format", "(", "field", ")", ",", "None", ")", "if", "value_method", "and", "callable", "(", "value_method", ")", ":", "ret", "[", "field", "]", "=", "value_method", "(", ")", "# now convert namespaced field names", "orig_field", "=", "field", "if", "prefix_field_names", ":", "parts", "=", "field", ".", "split", "(", "\"__\"", ")", "if", "len", "(", "parts", ")", ">", "1", ":", "index", "=", "parts", "[", "0", "]", "[", "1", ":", "]", "# trim the preceding '_'", "field", "=", "parts", "[", "1", "]", "if", "index", "==", "current_index", ":", "ret", "[", "field", "]", "=", "ret", "[", "orig_field", "]", "del", "ret", "[", "orig_field", "]", "elif", "field", "not", "in", "chain", "(", "instance", ".", "searchindex", ".", "fields", ".", "keys", "(", ")", ",", "self", ".", "_declared_fields", ".", "keys", "(", ")", ")", ":", "del", "ret", "[", "orig_field", "]", "# include the highlighted field in either case", "if", "getattr", "(", "instance", ",", "\"highlighted\"", ",", "None", ")", ":", "ret", "[", "\"highlighted\"", "]", "=", "instance", ".", "highlighted", "[", "0", "]", "return", "ret" ]
If we have a serializer mapping, use that. Otherwise, use standard serializer behavior Since we might be dealing with multiple indexes, some fields might not be valid for all results. Do not render the fields which don't belong to the search result.
[ "If", "we", "have", "a", "serializer", "mapping", "use", "that", ".", "Otherwise", "use", "standard", "serializer", "behavior", "Since", "we", "might", "be", "dealing", "with", "multiple", "indexes", "some", "fields", "might", "not", "be", "valid", "for", "all", "results", ".", "Do", "not", "render", "the", "fields", "which", "don", "t", "belong", "to", "the", "search", "result", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L216-L251
train
inonit/drf-haystack
drf_haystack/serializers.py
FacetFieldSerializer.get_narrow_url
def get_narrow_url(self, instance): """ Return a link suitable for narrowing on the current item. """ text = instance[0] request = self.context["request"] query_params = request.GET.copy() # Never keep the page query parameter in narrowing urls. # It will raise a NotFound exception when trying to paginate a narrowed queryset. page_query_param = self.get_paginate_by_param() if page_query_param and page_query_param in query_params: del query_params[page_query_param] selected_facets = set(query_params.pop(self.root.facet_query_params_text, [])) selected_facets.add("%(field)s_exact:%(text)s" % {"field": self.parent_field, "text": text}) query_params.setlist(self.root.facet_query_params_text, sorted(selected_facets)) path = "%(path)s?%(query)s" % {"path": request.path_info, "query": query_params.urlencode()} url = request.build_absolute_uri(path) return serializers.Hyperlink(url, "narrow-url")
python
def get_narrow_url(self, instance): """ Return a link suitable for narrowing on the current item. """ text = instance[0] request = self.context["request"] query_params = request.GET.copy() # Never keep the page query parameter in narrowing urls. # It will raise a NotFound exception when trying to paginate a narrowed queryset. page_query_param = self.get_paginate_by_param() if page_query_param and page_query_param in query_params: del query_params[page_query_param] selected_facets = set(query_params.pop(self.root.facet_query_params_text, [])) selected_facets.add("%(field)s_exact:%(text)s" % {"field": self.parent_field, "text": text}) query_params.setlist(self.root.facet_query_params_text, sorted(selected_facets)) path = "%(path)s?%(query)s" % {"path": request.path_info, "query": query_params.urlencode()} url = request.build_absolute_uri(path) return serializers.Hyperlink(url, "narrow-url")
[ "def", "get_narrow_url", "(", "self", ",", "instance", ")", ":", "text", "=", "instance", "[", "0", "]", "request", "=", "self", ".", "context", "[", "\"request\"", "]", "query_params", "=", "request", ".", "GET", ".", "copy", "(", ")", "# Never keep the page query parameter in narrowing urls.", "# It will raise a NotFound exception when trying to paginate a narrowed queryset.", "page_query_param", "=", "self", ".", "get_paginate_by_param", "(", ")", "if", "page_query_param", "and", "page_query_param", "in", "query_params", ":", "del", "query_params", "[", "page_query_param", "]", "selected_facets", "=", "set", "(", "query_params", ".", "pop", "(", "self", ".", "root", ".", "facet_query_params_text", ",", "[", "]", ")", ")", "selected_facets", ".", "add", "(", "\"%(field)s_exact:%(text)s\"", "%", "{", "\"field\"", ":", "self", ".", "parent_field", ",", "\"text\"", ":", "text", "}", ")", "query_params", ".", "setlist", "(", "self", ".", "root", ".", "facet_query_params_text", ",", "sorted", "(", "selected_facets", ")", ")", "path", "=", "\"%(path)s?%(query)s\"", "%", "{", "\"path\"", ":", "request", ".", "path_info", ",", "\"query\"", ":", "query_params", ".", "urlencode", "(", ")", "}", "url", "=", "request", ".", "build_absolute_uri", "(", "path", ")", "return", "serializers", ".", "Hyperlink", "(", "url", ",", "\"narrow-url\"", ")" ]
Return a link suitable for narrowing on the current item.
[ "Return", "a", "link", "suitable", "for", "narrowing", "on", "the", "current", "item", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L340-L360
train
inonit/drf-haystack
drf_haystack/serializers.py
FacetFieldSerializer.to_representation
def to_representation(self, field, instance): """ Set the ``parent_field`` property equal to the current field on the serializer class, so that each field can query it to see what kind of attribute they are processing. """ self.parent_field = field return super(FacetFieldSerializer, self).to_representation(instance)
python
def to_representation(self, field, instance): """ Set the ``parent_field`` property equal to the current field on the serializer class, so that each field can query it to see what kind of attribute they are processing. """ self.parent_field = field return super(FacetFieldSerializer, self).to_representation(instance)
[ "def", "to_representation", "(", "self", ",", "field", ",", "instance", ")", ":", "self", ".", "parent_field", "=", "field", "return", "super", "(", "FacetFieldSerializer", ",", "self", ")", ".", "to_representation", "(", "instance", ")" ]
Set the ``parent_field`` property equal to the current field on the serializer class, so that each field can query it to see what kind of attribute they are processing.
[ "Set", "the", "parent_field", "property", "equal", "to", "the", "current", "field", "on", "the", "serializer", "class", "so", "that", "each", "field", "can", "query", "it", "to", "see", "what", "kind", "of", "attribute", "they", "are", "processing", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L362-L368
train
inonit/drf-haystack
drf_haystack/serializers.py
HaystackFacetSerializer.get_fields
def get_fields(self): """ This returns a dictionary containing the top most fields, ``dates``, ``fields`` and ``queries``. """ field_mapping = OrderedDict() for field, data in self.instance.items(): field_mapping.update( {field: self.facet_dict_field_class( child=self.facet_list_field_class(child=self.facet_field_serializer_class(data)), required=False)} ) if self.serialize_objects is True: field_mapping["objects"] = serializers.SerializerMethodField() return field_mapping
python
def get_fields(self): """ This returns a dictionary containing the top most fields, ``dates``, ``fields`` and ``queries``. """ field_mapping = OrderedDict() for field, data in self.instance.items(): field_mapping.update( {field: self.facet_dict_field_class( child=self.facet_list_field_class(child=self.facet_field_serializer_class(data)), required=False)} ) if self.serialize_objects is True: field_mapping["objects"] = serializers.SerializerMethodField() return field_mapping
[ "def", "get_fields", "(", "self", ")", ":", "field_mapping", "=", "OrderedDict", "(", ")", "for", "field", ",", "data", "in", "self", ".", "instance", ".", "items", "(", ")", ":", "field_mapping", ".", "update", "(", "{", "field", ":", "self", ".", "facet_dict_field_class", "(", "child", "=", "self", ".", "facet_list_field_class", "(", "child", "=", "self", ".", "facet_field_serializer_class", "(", "data", ")", ")", ",", "required", "=", "False", ")", "}", ")", "if", "self", ".", "serialize_objects", "is", "True", ":", "field_mapping", "[", "\"objects\"", "]", "=", "serializers", ".", "SerializerMethodField", "(", ")", "return", "field_mapping" ]
This returns a dictionary containing the top most fields, ``dates``, ``fields`` and ``queries``.
[ "This", "returns", "a", "dictionary", "containing", "the", "top", "most", "fields", "dates", "fields", "and", "queries", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L384-L399
train
inonit/drf-haystack
drf_haystack/serializers.py
HaystackFacetSerializer.get_objects
def get_objects(self, instance): """ Return a list of objects matching the faceted result. """ view = self.context["view"] queryset = self.context["objects"] page = view.paginate_queryset(queryset) if page is not None: serializer = view.get_facet_objects_serializer(page, many=True) return OrderedDict([ ("count", self.get_count(queryset)), ("next", view.paginator.get_next_link()), ("previous", view.paginator.get_previous_link()), ("results", serializer.data) ]) serializer = view.get_serializer(queryset, many=True) return serializer.data
python
def get_objects(self, instance): """ Return a list of objects matching the faceted result. """ view = self.context["view"] queryset = self.context["objects"] page = view.paginate_queryset(queryset) if page is not None: serializer = view.get_facet_objects_serializer(page, many=True) return OrderedDict([ ("count", self.get_count(queryset)), ("next", view.paginator.get_next_link()), ("previous", view.paginator.get_previous_link()), ("results", serializer.data) ]) serializer = view.get_serializer(queryset, many=True) return serializer.data
[ "def", "get_objects", "(", "self", ",", "instance", ")", ":", "view", "=", "self", ".", "context", "[", "\"view\"", "]", "queryset", "=", "self", ".", "context", "[", "\"objects\"", "]", "page", "=", "view", ".", "paginate_queryset", "(", "queryset", ")", "if", "page", "is", "not", "None", ":", "serializer", "=", "view", ".", "get_facet_objects_serializer", "(", "page", ",", "many", "=", "True", ")", "return", "OrderedDict", "(", "[", "(", "\"count\"", ",", "self", ".", "get_count", "(", "queryset", ")", ")", ",", "(", "\"next\"", ",", "view", ".", "paginator", ".", "get_next_link", "(", ")", ")", ",", "(", "\"previous\"", ",", "view", ".", "paginator", ".", "get_previous_link", "(", ")", ")", ",", "(", "\"results\"", ",", "serializer", ".", "data", ")", "]", ")", "serializer", "=", "view", ".", "get_serializer", "(", "queryset", ",", "many", "=", "True", ")", "return", "serializer", ".", "data" ]
Return a list of objects matching the faceted result.
[ "Return", "a", "list", "of", "objects", "matching", "the", "faceted", "result", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L401-L419
train
inonit/drf-haystack
drf_haystack/serializers.py
HighlighterMixin.get_document_field
def get_document_field(instance): """ Returns which field the search index has marked as it's `document=True` field. """ for name, field in instance.searchindex.fields.items(): if field.document is True: return name
python
def get_document_field(instance): """ Returns which field the search index has marked as it's `document=True` field. """ for name, field in instance.searchindex.fields.items(): if field.document is True: return name
[ "def", "get_document_field", "(", "instance", ")", ":", "for", "name", ",", "field", "in", "instance", ".", "searchindex", ".", "fields", ".", "items", "(", ")", ":", "if", "field", ".", "document", "is", "True", ":", "return", "name" ]
Returns which field the search index has marked as it's `document=True` field.
[ "Returns", "which", "field", "the", "search", "index", "has", "marked", "as", "it", "s", "document", "=", "True", "field", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/serializers.py#L470-L477
train
inonit/drf-haystack
drf_haystack/filters.py
BaseHaystackFilterBackend.apply_filters
def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None): """ Apply constructed filters and excludes and return the queryset :param queryset: queryset to filter :param applicable_filters: filters which are passed directly to queryset.filter() :param applicable_exclusions: filters which are passed directly to queryset.exclude() :returns filtered queryset """ if applicable_filters: queryset = queryset.filter(applicable_filters) if applicable_exclusions: queryset = queryset.exclude(applicable_exclusions) return queryset
python
def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None): """ Apply constructed filters and excludes and return the queryset :param queryset: queryset to filter :param applicable_filters: filters which are passed directly to queryset.filter() :param applicable_exclusions: filters which are passed directly to queryset.exclude() :returns filtered queryset """ if applicable_filters: queryset = queryset.filter(applicable_filters) if applicable_exclusions: queryset = queryset.exclude(applicable_exclusions) return queryset
[ "def", "apply_filters", "(", "self", ",", "queryset", ",", "applicable_filters", "=", "None", ",", "applicable_exclusions", "=", "None", ")", ":", "if", "applicable_filters", ":", "queryset", "=", "queryset", ".", "filter", "(", "applicable_filters", ")", "if", "applicable_exclusions", ":", "queryset", "=", "queryset", ".", "exclude", "(", "applicable_exclusions", ")", "return", "queryset" ]
Apply constructed filters and excludes and return the queryset :param queryset: queryset to filter :param applicable_filters: filters which are passed directly to queryset.filter() :param applicable_exclusions: filters which are passed directly to queryset.exclude() :returns filtered queryset
[ "Apply", "constructed", "filters", "and", "excludes", "and", "return", "the", "queryset" ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/filters.py#L27-L40
train
inonit/drf-haystack
drf_haystack/filters.py
BaseHaystackFilterBackend.build_filters
def build_filters(self, view, filters=None): """ Get the query builder instance and return constructed query filters. """ query_builder = self.get_query_builder(backend=self, view=view) return query_builder.build_query(**(filters if filters else {}))
python
def build_filters(self, view, filters=None): """ Get the query builder instance and return constructed query filters. """ query_builder = self.get_query_builder(backend=self, view=view) return query_builder.build_query(**(filters if filters else {}))
[ "def", "build_filters", "(", "self", ",", "view", ",", "filters", "=", "None", ")", ":", "query_builder", "=", "self", ".", "get_query_builder", "(", "backend", "=", "self", ",", "view", "=", "view", ")", "return", "query_builder", ".", "build_query", "(", "*", "*", "(", "filters", "if", "filters", "else", "{", "}", ")", ")" ]
Get the query builder instance and return constructed query filters.
[ "Get", "the", "query", "builder", "instance", "and", "return", "constructed", "query", "filters", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/filters.py#L42-L47
train
inonit/drf-haystack
drf_haystack/filters.py
BaseHaystackFilterBackend.filter_queryset
def filter_queryset(self, request, queryset, view): """ Return the filtered queryset. """ applicable_filters, applicable_exclusions = self.build_filters(view, filters=self.get_request_filters(request)) return self.apply_filters( queryset=queryset, applicable_filters=self.process_filters(applicable_filters, queryset, view), applicable_exclusions=self.process_filters(applicable_exclusions, queryset, view) )
python
def filter_queryset(self, request, queryset, view): """ Return the filtered queryset. """ applicable_filters, applicable_exclusions = self.build_filters(view, filters=self.get_request_filters(request)) return self.apply_filters( queryset=queryset, applicable_filters=self.process_filters(applicable_filters, queryset, view), applicable_exclusions=self.process_filters(applicable_exclusions, queryset, view) )
[ "def", "filter_queryset", "(", "self", ",", "request", ",", "queryset", ",", "view", ")", ":", "applicable_filters", ",", "applicable_exclusions", "=", "self", ".", "build_filters", "(", "view", ",", "filters", "=", "self", ".", "get_request_filters", "(", "request", ")", ")", "return", "self", ".", "apply_filters", "(", "queryset", "=", "queryset", ",", "applicable_filters", "=", "self", ".", "process_filters", "(", "applicable_filters", ",", "queryset", ",", "view", ")", ",", "applicable_exclusions", "=", "self", ".", "process_filters", "(", "applicable_exclusions", ",", "queryset", ",", "view", ")", ")" ]
Return the filtered queryset.
[ "Return", "the", "filtered", "queryset", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/filters.py#L56-L65
train
inonit/drf-haystack
drf_haystack/filters.py
BaseHaystackFilterBackend.get_query_builder
def get_query_builder(self, *args, **kwargs): """ Return the query builder class instance that should be used to build the query which is passed to the search engine backend. """ query_builder = self.get_query_builder_class() return query_builder(*args, **kwargs)
python
def get_query_builder(self, *args, **kwargs): """ Return the query builder class instance that should be used to build the query which is passed to the search engine backend. """ query_builder = self.get_query_builder_class() return query_builder(*args, **kwargs)
[ "def", "get_query_builder", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "query_builder", "=", "self", ".", "get_query_builder_class", "(", ")", "return", "query_builder", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]
Return the query builder class instance that should be used to build the query which is passed to the search engine backend.
[ "Return", "the", "query", "builder", "class", "instance", "that", "should", "be", "used", "to", "build", "the", "query", "which", "is", "passed", "to", "the", "search", "engine", "backend", "." ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/filters.py#L67-L73
train
inonit/drf-haystack
drf_haystack/filters.py
HaystackFacetFilter.apply_filters
def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None): """ Apply faceting to the queryset """ for field, options in applicable_filters["field_facets"].items(): queryset = queryset.facet(field, **options) for field, options in applicable_filters["date_facets"].items(): queryset = queryset.date_facet(field, **options) for field, options in applicable_filters["query_facets"].items(): queryset = queryset.query_facet(field, **options) return queryset
python
def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None): """ Apply faceting to the queryset """ for field, options in applicable_filters["field_facets"].items(): queryset = queryset.facet(field, **options) for field, options in applicable_filters["date_facets"].items(): queryset = queryset.date_facet(field, **options) for field, options in applicable_filters["query_facets"].items(): queryset = queryset.query_facet(field, **options) return queryset
[ "def", "apply_filters", "(", "self", ",", "queryset", ",", "applicable_filters", "=", "None", ",", "applicable_exclusions", "=", "None", ")", ":", "for", "field", ",", "options", "in", "applicable_filters", "[", "\"field_facets\"", "]", ".", "items", "(", ")", ":", "queryset", "=", "queryset", ".", "facet", "(", "field", ",", "*", "*", "options", ")", "for", "field", ",", "options", "in", "applicable_filters", "[", "\"date_facets\"", "]", ".", "items", "(", ")", ":", "queryset", "=", "queryset", ".", "date_facet", "(", "field", ",", "*", "*", "options", ")", "for", "field", ",", "options", "in", "applicable_filters", "[", "\"query_facets\"", "]", ".", "items", "(", ")", ":", "queryset", "=", "queryset", ".", "query_facet", "(", "field", ",", "*", "*", "options", ")", "return", "queryset" ]
Apply faceting to the queryset
[ "Apply", "faceting", "to", "the", "queryset" ]
ceabd0f6318f129758341ab08292a20205d6f4cd
https://github.com/inonit/drf-haystack/blob/ceabd0f6318f129758341ab08292a20205d6f4cd/drf_haystack/filters.py#L202-L215
train
maximtrp/scikit-posthocs
scikit_posthocs/_posthocs.py
__convert_to_df
def __convert_to_df(a, val_col=None, group_col=None, val_id=None, group_id=None): '''Hidden helper method to create a DataFrame with input data for further processing. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. Second dimension may vary, i.e. groups may have different lengths. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. val_id : int, optional Index of a column that contains dependent variable values (test or response variable). Should be specified if a NumPy ndarray is used as an input. It will be inferred from data, if not specified. group_id : int, optional Index of a column that contains independent variable values (grouping or predictor variable). Should be specified if a NumPy ndarray is used as an input. It will be inferred from data, if not specified. Returns ------- x : pandas DataFrame DataFrame with input data, `val_col` column contains numerical values and `group_col` column contains categorical values. val_col : str Name of a DataFrame column that contains dependent variable values (test or response variable). group_col : str Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Notes ----- Inferrence algorithm for determining `val_id` and `group_id` args is rather simple, so it is better to specify them explicitly to prevent errors. ''' if not group_col: group_col = 'groups' if not val_col: val_col = 'vals' if isinstance(a, DataFrame): x = a.copy() if not {group_col, val_col}.issubset(a.columns): raise ValueError('Specify correct column names using `group_col` and `val_col` args') return x, val_col, group_col elif isinstance(a, list) or (isinstance(a, np.ndarray) and not a.shape.count(2)): grps_len = map(len, a) grps = list(it.chain(*[[i+1] * l for i, l in enumerate(grps_len)])) vals = list(it.chain(*a)) return DataFrame({val_col: vals, group_col: grps}), val_col, group_col elif isinstance(a, np.ndarray): # cols ids not defined # trying to infer if not(all([val_id, group_id])): if np.argmax(a.shape): a = a.T ax = [np.unique(a[:, 0]).size, np.unique(a[:, 1]).size] if np.asscalar(np.diff(ax)): __val_col = np.argmax(ax) __group_col = np.argmin(ax) else: raise ValueError('Cannot infer input format.\nPlease specify `val_id` and `group_id` args') cols = {__val_col: val_col, __group_col: group_col} else: cols = {val_id: val_col, group_id: group_col} cols_vals = dict(sorted(cols.items())).values() return DataFrame(a, columns=cols_vals), val_col, group_col
python
def __convert_to_df(a, val_col=None, group_col=None, val_id=None, group_id=None): '''Hidden helper method to create a DataFrame with input data for further processing. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. Second dimension may vary, i.e. groups may have different lengths. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. val_id : int, optional Index of a column that contains dependent variable values (test or response variable). Should be specified if a NumPy ndarray is used as an input. It will be inferred from data, if not specified. group_id : int, optional Index of a column that contains independent variable values (grouping or predictor variable). Should be specified if a NumPy ndarray is used as an input. It will be inferred from data, if not specified. Returns ------- x : pandas DataFrame DataFrame with input data, `val_col` column contains numerical values and `group_col` column contains categorical values. val_col : str Name of a DataFrame column that contains dependent variable values (test or response variable). group_col : str Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Notes ----- Inferrence algorithm for determining `val_id` and `group_id` args is rather simple, so it is better to specify them explicitly to prevent errors. ''' if not group_col: group_col = 'groups' if not val_col: val_col = 'vals' if isinstance(a, DataFrame): x = a.copy() if not {group_col, val_col}.issubset(a.columns): raise ValueError('Specify correct column names using `group_col` and `val_col` args') return x, val_col, group_col elif isinstance(a, list) or (isinstance(a, np.ndarray) and not a.shape.count(2)): grps_len = map(len, a) grps = list(it.chain(*[[i+1] * l for i, l in enumerate(grps_len)])) vals = list(it.chain(*a)) return DataFrame({val_col: vals, group_col: grps}), val_col, group_col elif isinstance(a, np.ndarray): # cols ids not defined # trying to infer if not(all([val_id, group_id])): if np.argmax(a.shape): a = a.T ax = [np.unique(a[:, 0]).size, np.unique(a[:, 1]).size] if np.asscalar(np.diff(ax)): __val_col = np.argmax(ax) __group_col = np.argmin(ax) else: raise ValueError('Cannot infer input format.\nPlease specify `val_id` and `group_id` args') cols = {__val_col: val_col, __group_col: group_col} else: cols = {val_id: val_col, group_id: group_col} cols_vals = dict(sorted(cols.items())).values() return DataFrame(a, columns=cols_vals), val_col, group_col
[ "def", "__convert_to_df", "(", "a", ",", "val_col", "=", "None", ",", "group_col", "=", "None", ",", "val_id", "=", "None", ",", "group_id", "=", "None", ")", ":", "if", "not", "group_col", ":", "group_col", "=", "'groups'", "if", "not", "val_col", ":", "val_col", "=", "'vals'", "if", "isinstance", "(", "a", ",", "DataFrame", ")", ":", "x", "=", "a", ".", "copy", "(", ")", "if", "not", "{", "group_col", ",", "val_col", "}", ".", "issubset", "(", "a", ".", "columns", ")", ":", "raise", "ValueError", "(", "'Specify correct column names using `group_col` and `val_col` args'", ")", "return", "x", ",", "val_col", ",", "group_col", "elif", "isinstance", "(", "a", ",", "list", ")", "or", "(", "isinstance", "(", "a", ",", "np", ".", "ndarray", ")", "and", "not", "a", ".", "shape", ".", "count", "(", "2", ")", ")", ":", "grps_len", "=", "map", "(", "len", ",", "a", ")", "grps", "=", "list", "(", "it", ".", "chain", "(", "*", "[", "[", "i", "+", "1", "]", "*", "l", "for", "i", ",", "l", "in", "enumerate", "(", "grps_len", ")", "]", ")", ")", "vals", "=", "list", "(", "it", ".", "chain", "(", "*", "a", ")", ")", "return", "DataFrame", "(", "{", "val_col", ":", "vals", ",", "group_col", ":", "grps", "}", ")", ",", "val_col", ",", "group_col", "elif", "isinstance", "(", "a", ",", "np", ".", "ndarray", ")", ":", "# cols ids not defined", "# trying to infer", "if", "not", "(", "all", "(", "[", "val_id", ",", "group_id", "]", ")", ")", ":", "if", "np", ".", "argmax", "(", "a", ".", "shape", ")", ":", "a", "=", "a", ".", "T", "ax", "=", "[", "np", ".", "unique", "(", "a", "[", ":", ",", "0", "]", ")", ".", "size", ",", "np", ".", "unique", "(", "a", "[", ":", ",", "1", "]", ")", ".", "size", "]", "if", "np", ".", "asscalar", "(", "np", ".", "diff", "(", "ax", ")", ")", ":", "__val_col", "=", "np", ".", "argmax", "(", "ax", ")", "__group_col", "=", "np", ".", "argmin", "(", "ax", ")", "else", ":", "raise", "ValueError", "(", "'Cannot infer input format.\\nPlease specify `val_id` and `group_id` args'", ")", "cols", "=", "{", "__val_col", ":", "val_col", ",", "__group_col", ":", "group_col", "}", "else", ":", "cols", "=", "{", "val_id", ":", "val_col", ",", "group_id", ":", "group_col", "}", "cols_vals", "=", "dict", "(", "sorted", "(", "cols", ".", "items", "(", ")", ")", ")", ".", "values", "(", ")", "return", "DataFrame", "(", "a", ",", "columns", "=", "cols_vals", ")", ",", "val_col", ",", "group_col" ]
Hidden helper method to create a DataFrame with input data for further processing. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. Second dimension may vary, i.e. groups may have different lengths. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. val_id : int, optional Index of a column that contains dependent variable values (test or response variable). Should be specified if a NumPy ndarray is used as an input. It will be inferred from data, if not specified. group_id : int, optional Index of a column that contains independent variable values (grouping or predictor variable). Should be specified if a NumPy ndarray is used as an input. It will be inferred from data, if not specified. Returns ------- x : pandas DataFrame DataFrame with input data, `val_col` column contains numerical values and `group_col` column contains categorical values. val_col : str Name of a DataFrame column that contains dependent variable values (test or response variable). group_col : str Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Notes ----- Inferrence algorithm for determining `val_id` and `group_id` args is rather simple, so it is better to specify them explicitly to prevent errors.
[ "Hidden", "helper", "method", "to", "create", "a", "DataFrame", "with", "input", "data", "for", "further", "processing", "." ]
5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d
https://github.com/maximtrp/scikit-posthocs/blob/5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d/scikit_posthocs/_posthocs.py#L11-L106
train
maximtrp/scikit-posthocs
scikit_posthocs/_posthocs.py
posthoc_tukey_hsd
def posthoc_tukey_hsd(x, g, alpha=0.05): '''Pairwise comparisons with TukeyHSD confidence intervals. This is a convenience function to make statsmodels `pairwise_tukeyhsd` method more applicable for further use. Parameters ---------- x : array_like or pandas Series object, 1d An array, any object exposing the array interface, containing dependent variable values (test or response variable). Values should have a non-nominal scale. NaN values will cause an error (please handle manually). g : array_like or pandas Series object, 1d An array, any object exposing the array interface, containing independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). alpha : float, optional Significance level for the test. Default is 0.05. Returns ------- result : pandas DataFrame DataFrame with 0, 1, and -1 values, where 0 is False (not significant), 1 is True (significant), and -1 is for diagonal elements. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> g = [['a'] * 5, ['b'] * 5, ['c'] * 5] >>> sp.posthoc_tukey_hsd(np.concatenate(x), np.concatenate(g)) ''' result = pairwise_tukeyhsd(x, g, alpha=0.05) groups = np.array(result.groupsunique, dtype=np.str) groups_len = len(groups) vs = np.zeros((groups_len, groups_len), dtype=np.int) for a in result.summary()[1:]: a0 = str(a[0]) a1 = str(a[1]) a0i = np.where(groups == a0)[0][0] a1i = np.where(groups == a1)[0][0] vs[a0i, a1i] = 1 if str(a[5]) == 'True' else 0 vs = np.triu(vs) np.fill_diagonal(vs, -1) tri_lower = np.tril_indices(vs.shape[0], -1) vs[tri_lower] = vs.T[tri_lower] return DataFrame(vs, index=groups, columns=groups)
python
def posthoc_tukey_hsd(x, g, alpha=0.05): '''Pairwise comparisons with TukeyHSD confidence intervals. This is a convenience function to make statsmodels `pairwise_tukeyhsd` method more applicable for further use. Parameters ---------- x : array_like or pandas Series object, 1d An array, any object exposing the array interface, containing dependent variable values (test or response variable). Values should have a non-nominal scale. NaN values will cause an error (please handle manually). g : array_like or pandas Series object, 1d An array, any object exposing the array interface, containing independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). alpha : float, optional Significance level for the test. Default is 0.05. Returns ------- result : pandas DataFrame DataFrame with 0, 1, and -1 values, where 0 is False (not significant), 1 is True (significant), and -1 is for diagonal elements. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> g = [['a'] * 5, ['b'] * 5, ['c'] * 5] >>> sp.posthoc_tukey_hsd(np.concatenate(x), np.concatenate(g)) ''' result = pairwise_tukeyhsd(x, g, alpha=0.05) groups = np.array(result.groupsunique, dtype=np.str) groups_len = len(groups) vs = np.zeros((groups_len, groups_len), dtype=np.int) for a in result.summary()[1:]: a0 = str(a[0]) a1 = str(a[1]) a0i = np.where(groups == a0)[0][0] a1i = np.where(groups == a1)[0][0] vs[a0i, a1i] = 1 if str(a[5]) == 'True' else 0 vs = np.triu(vs) np.fill_diagonal(vs, -1) tri_lower = np.tril_indices(vs.shape[0], -1) vs[tri_lower] = vs.T[tri_lower] return DataFrame(vs, index=groups, columns=groups)
[ "def", "posthoc_tukey_hsd", "(", "x", ",", "g", ",", "alpha", "=", "0.05", ")", ":", "result", "=", "pairwise_tukeyhsd", "(", "x", ",", "g", ",", "alpha", "=", "0.05", ")", "groups", "=", "np", ".", "array", "(", "result", ".", "groupsunique", ",", "dtype", "=", "np", ".", "str", ")", "groups_len", "=", "len", "(", "groups", ")", "vs", "=", "np", ".", "zeros", "(", "(", "groups_len", ",", "groups_len", ")", ",", "dtype", "=", "np", ".", "int", ")", "for", "a", "in", "result", ".", "summary", "(", ")", "[", "1", ":", "]", ":", "a0", "=", "str", "(", "a", "[", "0", "]", ")", "a1", "=", "str", "(", "a", "[", "1", "]", ")", "a0i", "=", "np", ".", "where", "(", "groups", "==", "a0", ")", "[", "0", "]", "[", "0", "]", "a1i", "=", "np", ".", "where", "(", "groups", "==", "a1", ")", "[", "0", "]", "[", "0", "]", "vs", "[", "a0i", ",", "a1i", "]", "=", "1", "if", "str", "(", "a", "[", "5", "]", ")", "==", "'True'", "else", "0", "vs", "=", "np", ".", "triu", "(", "vs", ")", "np", ".", "fill_diagonal", "(", "vs", ",", "-", "1", ")", "tri_lower", "=", "np", ".", "tril_indices", "(", "vs", ".", "shape", "[", "0", "]", ",", "-", "1", ")", "vs", "[", "tri_lower", "]", "=", "vs", ".", "T", "[", "tri_lower", "]", "return", "DataFrame", "(", "vs", ",", "index", "=", "groups", ",", "columns", "=", "groups", ")" ]
Pairwise comparisons with TukeyHSD confidence intervals. This is a convenience function to make statsmodels `pairwise_tukeyhsd` method more applicable for further use. Parameters ---------- x : array_like or pandas Series object, 1d An array, any object exposing the array interface, containing dependent variable values (test or response variable). Values should have a non-nominal scale. NaN values will cause an error (please handle manually). g : array_like or pandas Series object, 1d An array, any object exposing the array interface, containing independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). alpha : float, optional Significance level for the test. Default is 0.05. Returns ------- result : pandas DataFrame DataFrame with 0, 1, and -1 values, where 0 is False (not significant), 1 is True (significant), and -1 is for diagonal elements. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> g = [['a'] * 5, ['b'] * 5, ['c'] * 5] >>> sp.posthoc_tukey_hsd(np.concatenate(x), np.concatenate(g))
[ "Pairwise", "comparisons", "with", "TukeyHSD", "confidence", "intervals", ".", "This", "is", "a", "convenience", "function", "to", "make", "statsmodels", "pairwise_tukeyhsd", "method", "more", "applicable", "for", "further", "use", "." ]
5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d
https://github.com/maximtrp/scikit-posthocs/blob/5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d/scikit_posthocs/_posthocs.py#L1845-L1897
train
maximtrp/scikit-posthocs
scikit_posthocs/_posthocs.py
posthoc_mannwhitney
def posthoc_mannwhitney(a, val_col=None, group_col=None, use_continuity=True, alternative='two-sided', p_adjust=None, sort=True): '''Pairwise comparisons with Mann-Whitney rank test. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. use_continuity : bool, optional Whether a continuity correction (1/2.) should be taken into account. Default is True. alternative : ['two-sided', 'less', or 'greater'], optional Whether to get the p-value for the one-sided hypothesis ('less' or 'greater') or for the two-sided hypothesis ('two-sided'). Defaults to 'two-sided'. p_adjust : str, optional Method for adjusting p values. See statsmodels.sandbox.stats.multicomp for details. Available methods are: 'bonferroni' : one-step correction 'sidak' : one-step correction 'holm-sidak' : step-down method using Sidak adjustments 'holm' : step-down method using Bonferroni adjustments 'simes-hochberg' : step-up method (independent) 'hommel' : closed method based on Simes tests (non-negative) 'fdr_bh' : Benjamini/Hochberg (non-negative) 'fdr_by' : Benjamini/Yekutieli (negative) 'fdr_tsbh' : two stage fdr correction (non-negative) 'fdr_tsbky' : two stage fdr correction (non-negative) sort : bool, optional Specifies whether to sort DataFrame by group_col or not. Recommended unless you sort your data manually. Returns ------- result : pandas DataFrame P values. Notes ----- Refer to `scipy.stats.mannwhitneyu` reference page for further details. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> sp.posthoc_mannwhitney(x, p_adjust = 'holm') ''' x, _val_col, _group_col = __convert_to_df(a, val_col, group_col) if not sort: x[_group_col] = Categorical(x[_group_col], categories=x[_group_col].unique(), ordered=True) x.sort_values(by=[_group_col, _val_col], ascending=True, inplace=True) groups = np.unique(x[_group_col]) x_len = groups.size vs = np.zeros((x_len, x_len)) tri_upper = np.triu_indices(vs.shape[0], 1) tri_lower = np.tril_indices(vs.shape[0], -1) vs[:,:] = 0 combs = it.combinations(range(x_len), 2) for i,j in combs: vs[i, j] = ss.mannwhitneyu(x.loc[x[_group_col] == groups[i], _val_col], x.loc[x[_group_col] == groups[j], _val_col], use_continuity=use_continuity, alternative=alternative)[1] if p_adjust: vs[tri_upper] = multipletests(vs[tri_upper], method = p_adjust)[1] vs[tri_lower] = vs.T[tri_lower] np.fill_diagonal(vs, -1) return DataFrame(vs, index=groups, columns=groups)
python
def posthoc_mannwhitney(a, val_col=None, group_col=None, use_continuity=True, alternative='two-sided', p_adjust=None, sort=True): '''Pairwise comparisons with Mann-Whitney rank test. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. use_continuity : bool, optional Whether a continuity correction (1/2.) should be taken into account. Default is True. alternative : ['two-sided', 'less', or 'greater'], optional Whether to get the p-value for the one-sided hypothesis ('less' or 'greater') or for the two-sided hypothesis ('two-sided'). Defaults to 'two-sided'. p_adjust : str, optional Method for adjusting p values. See statsmodels.sandbox.stats.multicomp for details. Available methods are: 'bonferroni' : one-step correction 'sidak' : one-step correction 'holm-sidak' : step-down method using Sidak adjustments 'holm' : step-down method using Bonferroni adjustments 'simes-hochberg' : step-up method (independent) 'hommel' : closed method based on Simes tests (non-negative) 'fdr_bh' : Benjamini/Hochberg (non-negative) 'fdr_by' : Benjamini/Yekutieli (negative) 'fdr_tsbh' : two stage fdr correction (non-negative) 'fdr_tsbky' : two stage fdr correction (non-negative) sort : bool, optional Specifies whether to sort DataFrame by group_col or not. Recommended unless you sort your data manually. Returns ------- result : pandas DataFrame P values. Notes ----- Refer to `scipy.stats.mannwhitneyu` reference page for further details. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> sp.posthoc_mannwhitney(x, p_adjust = 'holm') ''' x, _val_col, _group_col = __convert_to_df(a, val_col, group_col) if not sort: x[_group_col] = Categorical(x[_group_col], categories=x[_group_col].unique(), ordered=True) x.sort_values(by=[_group_col, _val_col], ascending=True, inplace=True) groups = np.unique(x[_group_col]) x_len = groups.size vs = np.zeros((x_len, x_len)) tri_upper = np.triu_indices(vs.shape[0], 1) tri_lower = np.tril_indices(vs.shape[0], -1) vs[:,:] = 0 combs = it.combinations(range(x_len), 2) for i,j in combs: vs[i, j] = ss.mannwhitneyu(x.loc[x[_group_col] == groups[i], _val_col], x.loc[x[_group_col] == groups[j], _val_col], use_continuity=use_continuity, alternative=alternative)[1] if p_adjust: vs[tri_upper] = multipletests(vs[tri_upper], method = p_adjust)[1] vs[tri_lower] = vs.T[tri_lower] np.fill_diagonal(vs, -1) return DataFrame(vs, index=groups, columns=groups)
[ "def", "posthoc_mannwhitney", "(", "a", ",", "val_col", "=", "None", ",", "group_col", "=", "None", ",", "use_continuity", "=", "True", ",", "alternative", "=", "'two-sided'", ",", "p_adjust", "=", "None", ",", "sort", "=", "True", ")", ":", "x", ",", "_val_col", ",", "_group_col", "=", "__convert_to_df", "(", "a", ",", "val_col", ",", "group_col", ")", "if", "not", "sort", ":", "x", "[", "_group_col", "]", "=", "Categorical", "(", "x", "[", "_group_col", "]", ",", "categories", "=", "x", "[", "_group_col", "]", ".", "unique", "(", ")", ",", "ordered", "=", "True", ")", "x", ".", "sort_values", "(", "by", "=", "[", "_group_col", ",", "_val_col", "]", ",", "ascending", "=", "True", ",", "inplace", "=", "True", ")", "groups", "=", "np", ".", "unique", "(", "x", "[", "_group_col", "]", ")", "x_len", "=", "groups", ".", "size", "vs", "=", "np", ".", "zeros", "(", "(", "x_len", ",", "x_len", ")", ")", "tri_upper", "=", "np", ".", "triu_indices", "(", "vs", ".", "shape", "[", "0", "]", ",", "1", ")", "tri_lower", "=", "np", ".", "tril_indices", "(", "vs", ".", "shape", "[", "0", "]", ",", "-", "1", ")", "vs", "[", ":", ",", ":", "]", "=", "0", "combs", "=", "it", ".", "combinations", "(", "range", "(", "x_len", ")", ",", "2", ")", "for", "i", ",", "j", "in", "combs", ":", "vs", "[", "i", ",", "j", "]", "=", "ss", ".", "mannwhitneyu", "(", "x", ".", "loc", "[", "x", "[", "_group_col", "]", "==", "groups", "[", "i", "]", ",", "_val_col", "]", ",", "x", ".", "loc", "[", "x", "[", "_group_col", "]", "==", "groups", "[", "j", "]", ",", "_val_col", "]", ",", "use_continuity", "=", "use_continuity", ",", "alternative", "=", "alternative", ")", "[", "1", "]", "if", "p_adjust", ":", "vs", "[", "tri_upper", "]", "=", "multipletests", "(", "vs", "[", "tri_upper", "]", ",", "method", "=", "p_adjust", ")", "[", "1", "]", "vs", "[", "tri_lower", "]", "=", "vs", ".", "T", "[", "tri_lower", "]", "np", ".", "fill_diagonal", "(", "vs", ",", "-", "1", ")", "return", "DataFrame", "(", "vs", ",", "index", "=", "groups", ",", "columns", "=", "groups", ")" ]
Pairwise comparisons with Mann-Whitney rank test. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. use_continuity : bool, optional Whether a continuity correction (1/2.) should be taken into account. Default is True. alternative : ['two-sided', 'less', or 'greater'], optional Whether to get the p-value for the one-sided hypothesis ('less' or 'greater') or for the two-sided hypothesis ('two-sided'). Defaults to 'two-sided'. p_adjust : str, optional Method for adjusting p values. See statsmodels.sandbox.stats.multicomp for details. Available methods are: 'bonferroni' : one-step correction 'sidak' : one-step correction 'holm-sidak' : step-down method using Sidak adjustments 'holm' : step-down method using Bonferroni adjustments 'simes-hochberg' : step-up method (independent) 'hommel' : closed method based on Simes tests (non-negative) 'fdr_bh' : Benjamini/Hochberg (non-negative) 'fdr_by' : Benjamini/Yekutieli (negative) 'fdr_tsbh' : two stage fdr correction (non-negative) 'fdr_tsbky' : two stage fdr correction (non-negative) sort : bool, optional Specifies whether to sort DataFrame by group_col or not. Recommended unless you sort your data manually. Returns ------- result : pandas DataFrame P values. Notes ----- Refer to `scipy.stats.mannwhitneyu` reference page for further details. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> sp.posthoc_mannwhitney(x, p_adjust = 'holm')
[ "Pairwise", "comparisons", "with", "Mann", "-", "Whitney", "rank", "test", "." ]
5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d
https://github.com/maximtrp/scikit-posthocs/blob/5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d/scikit_posthocs/_posthocs.py#L1900-L1991
train
maximtrp/scikit-posthocs
scikit_posthocs/_posthocs.py
posthoc_wilcoxon
def posthoc_wilcoxon(a, val_col=None, group_col=None, zero_method='wilcox', correction=False, p_adjust=None, sort=False): '''Pairwise comparisons with Wilcoxon signed-rank test. It is a non-parametric version of the paired T-test for use with non-parametric ANOVA. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. zero_method : string, {"pratt", "wilcox", "zsplit"}, optional "pratt": Pratt treatment, includes zero-differences in the ranking process (more conservative) "wilcox": Wilcox treatment, discards all zero-differences "zsplit": Zero rank split, just like Pratt, but spliting the zero rank between positive and negative ones correction : bool, optional If True, apply continuity correction by adjusting the Wilcoxon rank statistic by 0.5 towards the mean value when computing the z-statistic. Default is False. p_adjust : str, optional Method for adjusting p values. See statsmodels.sandbox.stats.multicomp for details. Available methods are: 'bonferroni' : one-step correction 'sidak' : one-step correction 'holm-sidak' : step-down method using Sidak adjustments 'holm' : step-down method using Bonferroni adjustments 'simes-hochberg' : step-up method (independent) 'hommel' : closed method based on Simes tests (non-negative) 'fdr_bh' : Benjamini/Hochberg (non-negative) 'fdr_by' : Benjamini/Yekutieli (negative) 'fdr_tsbh' : two stage fdr correction (non-negative) 'fdr_tsbky' : two stage fdr correction (non-negative) sort : bool, optional Specifies whether to sort DataFrame by group_col and val_col or not. Default is False. Returns ------- result : pandas DataFrame P values. Notes ----- Refer to `scipy.stats.wilcoxon` reference page for further details. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> sp.posthoc_wilcoxon(x) ''' x, _val_col, _group_col = __convert_to_df(a, val_col, group_col) if not sort: x[_group_col] = Categorical(x[_group_col], categories=x[_group_col].unique(), ordered=True) #x.sort_values(by=[_group_col, _val_col], ascending=True, inplace=True) groups = np.unique(x[_group_col]) x_len = groups.size vs = np.zeros((x_len, x_len)) tri_upper = np.triu_indices(vs.shape[0], 1) tri_lower = np.tril_indices(vs.shape[0], -1) vs[:,:] = 0 combs = it.combinations(range(x_len), 2) for i,j in combs: vs[i, j] = ss.wilcoxon(x.loc[x[_group_col] == groups[i], _val_col], x.loc[x[_group_col] == groups[j], _val_col], zero_method=zero_method, correction=correction)[1] if p_adjust: vs[tri_upper] = multipletests(vs[tri_upper], method=p_adjust)[1] vs[tri_lower] = vs.T[tri_lower] np.fill_diagonal(vs, -1) return DataFrame(vs, index=groups, columns=groups)
python
def posthoc_wilcoxon(a, val_col=None, group_col=None, zero_method='wilcox', correction=False, p_adjust=None, sort=False): '''Pairwise comparisons with Wilcoxon signed-rank test. It is a non-parametric version of the paired T-test for use with non-parametric ANOVA. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. zero_method : string, {"pratt", "wilcox", "zsplit"}, optional "pratt": Pratt treatment, includes zero-differences in the ranking process (more conservative) "wilcox": Wilcox treatment, discards all zero-differences "zsplit": Zero rank split, just like Pratt, but spliting the zero rank between positive and negative ones correction : bool, optional If True, apply continuity correction by adjusting the Wilcoxon rank statistic by 0.5 towards the mean value when computing the z-statistic. Default is False. p_adjust : str, optional Method for adjusting p values. See statsmodels.sandbox.stats.multicomp for details. Available methods are: 'bonferroni' : one-step correction 'sidak' : one-step correction 'holm-sidak' : step-down method using Sidak adjustments 'holm' : step-down method using Bonferroni adjustments 'simes-hochberg' : step-up method (independent) 'hommel' : closed method based on Simes tests (non-negative) 'fdr_bh' : Benjamini/Hochberg (non-negative) 'fdr_by' : Benjamini/Yekutieli (negative) 'fdr_tsbh' : two stage fdr correction (non-negative) 'fdr_tsbky' : two stage fdr correction (non-negative) sort : bool, optional Specifies whether to sort DataFrame by group_col and val_col or not. Default is False. Returns ------- result : pandas DataFrame P values. Notes ----- Refer to `scipy.stats.wilcoxon` reference page for further details. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> sp.posthoc_wilcoxon(x) ''' x, _val_col, _group_col = __convert_to_df(a, val_col, group_col) if not sort: x[_group_col] = Categorical(x[_group_col], categories=x[_group_col].unique(), ordered=True) #x.sort_values(by=[_group_col, _val_col], ascending=True, inplace=True) groups = np.unique(x[_group_col]) x_len = groups.size vs = np.zeros((x_len, x_len)) tri_upper = np.triu_indices(vs.shape[0], 1) tri_lower = np.tril_indices(vs.shape[0], -1) vs[:,:] = 0 combs = it.combinations(range(x_len), 2) for i,j in combs: vs[i, j] = ss.wilcoxon(x.loc[x[_group_col] == groups[i], _val_col], x.loc[x[_group_col] == groups[j], _val_col], zero_method=zero_method, correction=correction)[1] if p_adjust: vs[tri_upper] = multipletests(vs[tri_upper], method=p_adjust)[1] vs[tri_lower] = vs.T[tri_lower] np.fill_diagonal(vs, -1) return DataFrame(vs, index=groups, columns=groups)
[ "def", "posthoc_wilcoxon", "(", "a", ",", "val_col", "=", "None", ",", "group_col", "=", "None", ",", "zero_method", "=", "'wilcox'", ",", "correction", "=", "False", ",", "p_adjust", "=", "None", ",", "sort", "=", "False", ")", ":", "x", ",", "_val_col", ",", "_group_col", "=", "__convert_to_df", "(", "a", ",", "val_col", ",", "group_col", ")", "if", "not", "sort", ":", "x", "[", "_group_col", "]", "=", "Categorical", "(", "x", "[", "_group_col", "]", ",", "categories", "=", "x", "[", "_group_col", "]", ".", "unique", "(", ")", ",", "ordered", "=", "True", ")", "#x.sort_values(by=[_group_col, _val_col], ascending=True, inplace=True)", "groups", "=", "np", ".", "unique", "(", "x", "[", "_group_col", "]", ")", "x_len", "=", "groups", ".", "size", "vs", "=", "np", ".", "zeros", "(", "(", "x_len", ",", "x_len", ")", ")", "tri_upper", "=", "np", ".", "triu_indices", "(", "vs", ".", "shape", "[", "0", "]", ",", "1", ")", "tri_lower", "=", "np", ".", "tril_indices", "(", "vs", ".", "shape", "[", "0", "]", ",", "-", "1", ")", "vs", "[", ":", ",", ":", "]", "=", "0", "combs", "=", "it", ".", "combinations", "(", "range", "(", "x_len", ")", ",", "2", ")", "for", "i", ",", "j", "in", "combs", ":", "vs", "[", "i", ",", "j", "]", "=", "ss", ".", "wilcoxon", "(", "x", ".", "loc", "[", "x", "[", "_group_col", "]", "==", "groups", "[", "i", "]", ",", "_val_col", "]", ",", "x", ".", "loc", "[", "x", "[", "_group_col", "]", "==", "groups", "[", "j", "]", ",", "_val_col", "]", ",", "zero_method", "=", "zero_method", ",", "correction", "=", "correction", ")", "[", "1", "]", "if", "p_adjust", ":", "vs", "[", "tri_upper", "]", "=", "multipletests", "(", "vs", "[", "tri_upper", "]", ",", "method", "=", "p_adjust", ")", "[", "1", "]", "vs", "[", "tri_lower", "]", "=", "vs", ".", "T", "[", "tri_lower", "]", "np", ".", "fill_diagonal", "(", "vs", ",", "-", "1", ")", "return", "DataFrame", "(", "vs", ",", "index", "=", "groups", ",", "columns", "=", "groups", ")" ]
Pairwise comparisons with Wilcoxon signed-rank test. It is a non-parametric version of the paired T-test for use with non-parametric ANOVA. Parameters ---------- a : array_like or pandas DataFrame object An array, any object exposing the array interface or a pandas DataFrame. Array must be two-dimensional. val_col : str, optional Name of a DataFrame column that contains dependent variable values (test or response variable). Values should have a non-nominal scale. Must be specified if `a` is a pandas DataFrame object. group_col : str, optional Name of a DataFrame column that contains independent variable values (grouping or predictor variable). Values should have a nominal scale (categorical). Must be specified if `a` is a pandas DataFrame object. zero_method : string, {"pratt", "wilcox", "zsplit"}, optional "pratt": Pratt treatment, includes zero-differences in the ranking process (more conservative) "wilcox": Wilcox treatment, discards all zero-differences "zsplit": Zero rank split, just like Pratt, but spliting the zero rank between positive and negative ones correction : bool, optional If True, apply continuity correction by adjusting the Wilcoxon rank statistic by 0.5 towards the mean value when computing the z-statistic. Default is False. p_adjust : str, optional Method for adjusting p values. See statsmodels.sandbox.stats.multicomp for details. Available methods are: 'bonferroni' : one-step correction 'sidak' : one-step correction 'holm-sidak' : step-down method using Sidak adjustments 'holm' : step-down method using Bonferroni adjustments 'simes-hochberg' : step-up method (independent) 'hommel' : closed method based on Simes tests (non-negative) 'fdr_bh' : Benjamini/Hochberg (non-negative) 'fdr_by' : Benjamini/Yekutieli (negative) 'fdr_tsbh' : two stage fdr correction (non-negative) 'fdr_tsbky' : two stage fdr correction (non-negative) sort : bool, optional Specifies whether to sort DataFrame by group_col and val_col or not. Default is False. Returns ------- result : pandas DataFrame P values. Notes ----- Refer to `scipy.stats.wilcoxon` reference page for further details. Examples -------- >>> x = [[1,2,3,4,5], [35,31,75,40,21], [10,6,9,6,1]] >>> sp.posthoc_wilcoxon(x)
[ "Pairwise", "comparisons", "with", "Wilcoxon", "signed", "-", "rank", "test", ".", "It", "is", "a", "non", "-", "parametric", "version", "of", "the", "paired", "T", "-", "test", "for", "use", "with", "non", "-", "parametric", "ANOVA", "." ]
5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d
https://github.com/maximtrp/scikit-posthocs/blob/5476b09e2a325cd4e31c0b0bc6906ab5cd77fc5d/scikit_posthocs/_posthocs.py#L1994-L2086
train
cjrh/aiorun
aiorun.py
shutdown_waits_for
def shutdown_waits_for(coro, loop=None): """Prevent coro from being cancelled during the shutdown sequence. The trick here is that we add this coro to the global "DO_NOT_CANCEL" collection, and then later during the shutdown sequence we make sure that the task that wraps this coro will NOT be cancelled. To make this work, we have to create a super-secret task, below, that communicates with the caller (which "awaits" us) via a Future. Using a Future in this way allows us to avoid awaiting the Task, which decouples the Task from the normal exception propagation which would normally happen when the outer Task gets cancelled. We get the result of coro back to the caller via Future.set_result. NOTE that during the shutdown sequence, the caller WILL NOT be able to receive a result, since the caller will likely have been cancelled. So you should probably not rely on capturing results via this function. """ loop = loop or get_event_loop() fut = loop.create_future() # This future will connect coro and the caller. async def coro_proxy(): """This function will await coro, but it will also send the result over the the future. Remember: the outside caller (of shutdown_waits_for) will be awaiting fut, NOT coro(), due to the decoupling. However, when coro completes, we need to send its result over to the fut to make it look *as if* it was just coro running the whole time. This whole thing is a teeny magic trick. """ try: result = await coro except (CancelledError, Exception) as e: set_fut_done = partial(fut.set_exception, e) else: set_fut_done = partial(fut.set_result, result) if not fut.cancelled(): set_fut_done() new_coro = coro_proxy() # We'll taskify this one instead of coro. _DO_NOT_CANCEL_COROS.add(new_coro) # The new task must not be cancelled. loop.create_task(new_coro) # Make the task # Ok, so we *could* simply return fut. Callers can await it as normal, # e.g. # # async def blah(): # x = await shutdown_waits_for(bleh()) # # That will work fine. However, callers may *also* want to detach the # call from the current execution context, e.g. # # async def blah(): # loop.create_task(shutdown_waits_for(bleh())) # # This will only work if shutdown_waits_for() returns a coroutine. # Therefore, we just make a new coroutine to wrap the `await fut` and # return that. Then both things will work. # # (Side note: instead of callers using create_tasks, it would also work # if they used `asyncio.ensure_future()` instead, since that can work # with futures. But I don't like ensure_future.) # # (Another side note: You don't even need `create_task()` or # `ensure_future()`...If you don't want a result, you can just call # `shutdown_waits_for()` as a flat function call, no await or anything, # and it should still work; unfortunately it causes a RuntimeWarning to # tell you that ``inner()`` was never awaited :/ async def inner(): return await fut return inner()
python
def shutdown_waits_for(coro, loop=None): """Prevent coro from being cancelled during the shutdown sequence. The trick here is that we add this coro to the global "DO_NOT_CANCEL" collection, and then later during the shutdown sequence we make sure that the task that wraps this coro will NOT be cancelled. To make this work, we have to create a super-secret task, below, that communicates with the caller (which "awaits" us) via a Future. Using a Future in this way allows us to avoid awaiting the Task, which decouples the Task from the normal exception propagation which would normally happen when the outer Task gets cancelled. We get the result of coro back to the caller via Future.set_result. NOTE that during the shutdown sequence, the caller WILL NOT be able to receive a result, since the caller will likely have been cancelled. So you should probably not rely on capturing results via this function. """ loop = loop or get_event_loop() fut = loop.create_future() # This future will connect coro and the caller. async def coro_proxy(): """This function will await coro, but it will also send the result over the the future. Remember: the outside caller (of shutdown_waits_for) will be awaiting fut, NOT coro(), due to the decoupling. However, when coro completes, we need to send its result over to the fut to make it look *as if* it was just coro running the whole time. This whole thing is a teeny magic trick. """ try: result = await coro except (CancelledError, Exception) as e: set_fut_done = partial(fut.set_exception, e) else: set_fut_done = partial(fut.set_result, result) if not fut.cancelled(): set_fut_done() new_coro = coro_proxy() # We'll taskify this one instead of coro. _DO_NOT_CANCEL_COROS.add(new_coro) # The new task must not be cancelled. loop.create_task(new_coro) # Make the task # Ok, so we *could* simply return fut. Callers can await it as normal, # e.g. # # async def blah(): # x = await shutdown_waits_for(bleh()) # # That will work fine. However, callers may *also* want to detach the # call from the current execution context, e.g. # # async def blah(): # loop.create_task(shutdown_waits_for(bleh())) # # This will only work if shutdown_waits_for() returns a coroutine. # Therefore, we just make a new coroutine to wrap the `await fut` and # return that. Then both things will work. # # (Side note: instead of callers using create_tasks, it would also work # if they used `asyncio.ensure_future()` instead, since that can work # with futures. But I don't like ensure_future.) # # (Another side note: You don't even need `create_task()` or # `ensure_future()`...If you don't want a result, you can just call # `shutdown_waits_for()` as a flat function call, no await or anything, # and it should still work; unfortunately it causes a RuntimeWarning to # tell you that ``inner()`` was never awaited :/ async def inner(): return await fut return inner()
[ "def", "shutdown_waits_for", "(", "coro", ",", "loop", "=", "None", ")", ":", "loop", "=", "loop", "or", "get_event_loop", "(", ")", "fut", "=", "loop", ".", "create_future", "(", ")", "# This future will connect coro and the caller.", "async", "def", "coro_proxy", "(", ")", ":", "\"\"\"This function will await coro, but it will also send the result\n over the the future. Remember: the outside caller (of\n shutdown_waits_for) will be awaiting fut, NOT coro(), due to\n the decoupling. However, when coro completes, we need to send its\n result over to the fut to make it look *as if* it was just coro\n running the whole time. This whole thing is a teeny magic trick.\n \"\"\"", "try", ":", "result", "=", "await", "coro", "except", "(", "CancelledError", ",", "Exception", ")", "as", "e", ":", "set_fut_done", "=", "partial", "(", "fut", ".", "set_exception", ",", "e", ")", "else", ":", "set_fut_done", "=", "partial", "(", "fut", ".", "set_result", ",", "result", ")", "if", "not", "fut", ".", "cancelled", "(", ")", ":", "set_fut_done", "(", ")", "new_coro", "=", "coro_proxy", "(", ")", "# We'll taskify this one instead of coro.", "_DO_NOT_CANCEL_COROS", ".", "add", "(", "new_coro", ")", "# The new task must not be cancelled.", "loop", ".", "create_task", "(", "new_coro", ")", "# Make the task", "# Ok, so we *could* simply return fut. Callers can await it as normal,", "# e.g.", "#", "# async def blah():", "# x = await shutdown_waits_for(bleh())", "#", "# That will work fine. However, callers may *also* want to detach the", "# call from the current execution context, e.g.", "#", "# async def blah():", "# loop.create_task(shutdown_waits_for(bleh()))", "#", "# This will only work if shutdown_waits_for() returns a coroutine.", "# Therefore, we just make a new coroutine to wrap the `await fut` and", "# return that. Then both things will work.", "#", "# (Side note: instead of callers using create_tasks, it would also work", "# if they used `asyncio.ensure_future()` instead, since that can work", "# with futures. But I don't like ensure_future.)", "#", "# (Another side note: You don't even need `create_task()` or", "# `ensure_future()`...If you don't want a result, you can just call", "# `shutdown_waits_for()` as a flat function call, no await or anything,", "# and it should still work; unfortunately it causes a RuntimeWarning to", "# tell you that ``inner()`` was never awaited :/", "async", "def", "inner", "(", ")", ":", "return", "await", "fut", "return", "inner", "(", ")" ]
Prevent coro from being cancelled during the shutdown sequence. The trick here is that we add this coro to the global "DO_NOT_CANCEL" collection, and then later during the shutdown sequence we make sure that the task that wraps this coro will NOT be cancelled. To make this work, we have to create a super-secret task, below, that communicates with the caller (which "awaits" us) via a Future. Using a Future in this way allows us to avoid awaiting the Task, which decouples the Task from the normal exception propagation which would normally happen when the outer Task gets cancelled. We get the result of coro back to the caller via Future.set_result. NOTE that during the shutdown sequence, the caller WILL NOT be able to receive a result, since the caller will likely have been cancelled. So you should probably not rely on capturing results via this function.
[ "Prevent", "coro", "from", "being", "cancelled", "during", "the", "shutdown", "sequence", "." ]
23c73318447f578a4a24845c5f43574ac7b414e4
https://github.com/cjrh/aiorun/blob/23c73318447f578a4a24845c5f43574ac7b414e4/aiorun.py#L43-L117
train
cjrh/aiorun
aiorun.py
run
def run(coro: 'Optional[Coroutine]' = None, *, loop: Optional[AbstractEventLoop] = None, shutdown_handler: Optional[Callable[[AbstractEventLoop], None]] = None, executor_workers: int = 10, executor: Optional[Executor] = None, use_uvloop: bool = False) -> None: """ Start up the event loop, and wait for a signal to shut down. :param coro: Optionally supply a coroutine. The loop will still run if missing. The loop will continue to run after the supplied coroutine finishes. The supplied coroutine is typically a "main" coroutine from which all other work is spawned. :param loop: Optionally supply your own loop. If missing, the default loop attached to the current thread context will be used, i.e., whatever ``asyncio.get_event_loop()`` returns. :param shutdown_handler: By default, SIGINT and SIGTERM will be handled and will stop the loop, thereby invoking the shutdown sequence. Alternatively you can supply your own shutdown handler function. It should conform to the type spec as shown in the function signature. :param executor_workers: The number of workers in the executor. (NOTE: ``run()`` creates a new executor instance internally, regardless of whether you supply your own loop.) :param executor: You can decide to use your own executor instance if you like. :param use_uvloop: The loop policy will be set to use uvloop. It is your responsibility to install uvloop. If missing, an ``ImportError`` will be raised. """ logger.debug('Entering run()') assert not (loop and use_uvloop), ( "'loop' and 'use_uvloop' parameters are mutually " "exclusive. (Just make your own uvloop and pass it in)." ) if use_uvloop: import uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) loop_was_supplied = bool(loop) if not loop_was_supplied: loop = get_event_loop() if coro: async def new_coro(): """During shutdown, run_until_complete() will exit if a CancelledError bubbles up from anything in the group. To counteract that, we'll try to handle any CancelledErrors that bubble up from the given coro. This isn't fool-proof: if the user doesn't provide a coro, and instead creates their own with loop.create_task, that task might bubble a CancelledError into the run_until_complete().""" try: await coro except asyncio.CancelledError: pass loop.create_task(new_coro()) shutdown_handler = shutdown_handler or _shutdown_handler if WINDOWS: # pragma: no cover # This is to allow CTRL-C to be detected in a timely fashion, # see: https://bugs.python.org/issue23057#msg246316 loop.create_task(windows_support_wakeup()) # This is to be able to handle SIGBREAK. def windows_handler(sig, frame): # Disable the handler so it won't be called again. signame = signal.Signals(sig).name logger.critical('Received signal: %s. Stopping the loop.', signame) shutdown_handler(loop) signal.signal(signal.SIGBREAK, windows_handler) signal.signal(signal.SIGINT, windows_handler) else: loop.add_signal_handler(SIGINT, shutdown_handler, loop) loop.add_signal_handler(SIGTERM, shutdown_handler, loop) # TODO: We probably don't want to create a different executor if the # TODO: loop was supplied. (User might have put stuff on that loop's # TODO: executor). if not executor: logger.debug('Creating default executor') executor = ThreadPoolExecutor(max_workers=executor_workers) loop.set_default_executor(executor) try: loop.run_forever() except KeyboardInterrupt: # pragma: no cover logger.info('Got KeyboardInterrupt') if WINDOWS: # Windows doesn't do any POSIX signal handling, and no # abstraction layer for signals is currently implemented in # asyncio. So we fall back to KeyboardInterrupt (triggered # by the user/environment sending CTRL-C, or signal.CTRL_C_EVENT shutdown_handler() logger.info('Entering shutdown phase.') def sep(): tasks = all_tasks(loop=loop) do_not_cancel = set() for t in tasks: # TODO: we don't need access to the coro. We could simply # TODO: store the task itself in the weakset. if t._coro in _DO_NOT_CANCEL_COROS: do_not_cancel.add(t) tasks -= do_not_cancel logger.info('Cancelling pending tasks.') for t in tasks: logger.debug('Cancelling task: %s', t) t.cancel() return tasks, do_not_cancel tasks, do_not_cancel = sep() # Here's a protip: if you group a bunch of tasks, and some of them # get cancelled, and they DON'T HANDLE THE CANCELLATION, then the # raised CancelledError will bubble up to, and stop the # loop.run_until_complete() line: meaning, not all the tasks in # the gathered group will actually be complete. You need to # enable this with the ``return_exceptions`` flag. group = gather(*tasks, *do_not_cancel, return_exceptions=True) logger.info('Running pending tasks till complete') # TODO: obtain all the results, and log any results that are exceptions # other than CancelledError. Will be useful for troubleshooting. loop.run_until_complete(group) logger.info('Waiting for executor shutdown.') executor.shutdown(wait=True) # If loop was supplied, it's up to the caller to close! if not loop_was_supplied: logger.info('Closing the loop.') loop.close() logger.critical('Leaving. Bye!')
python
def run(coro: 'Optional[Coroutine]' = None, *, loop: Optional[AbstractEventLoop] = None, shutdown_handler: Optional[Callable[[AbstractEventLoop], None]] = None, executor_workers: int = 10, executor: Optional[Executor] = None, use_uvloop: bool = False) -> None: """ Start up the event loop, and wait for a signal to shut down. :param coro: Optionally supply a coroutine. The loop will still run if missing. The loop will continue to run after the supplied coroutine finishes. The supplied coroutine is typically a "main" coroutine from which all other work is spawned. :param loop: Optionally supply your own loop. If missing, the default loop attached to the current thread context will be used, i.e., whatever ``asyncio.get_event_loop()`` returns. :param shutdown_handler: By default, SIGINT and SIGTERM will be handled and will stop the loop, thereby invoking the shutdown sequence. Alternatively you can supply your own shutdown handler function. It should conform to the type spec as shown in the function signature. :param executor_workers: The number of workers in the executor. (NOTE: ``run()`` creates a new executor instance internally, regardless of whether you supply your own loop.) :param executor: You can decide to use your own executor instance if you like. :param use_uvloop: The loop policy will be set to use uvloop. It is your responsibility to install uvloop. If missing, an ``ImportError`` will be raised. """ logger.debug('Entering run()') assert not (loop and use_uvloop), ( "'loop' and 'use_uvloop' parameters are mutually " "exclusive. (Just make your own uvloop and pass it in)." ) if use_uvloop: import uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) loop_was_supplied = bool(loop) if not loop_was_supplied: loop = get_event_loop() if coro: async def new_coro(): """During shutdown, run_until_complete() will exit if a CancelledError bubbles up from anything in the group. To counteract that, we'll try to handle any CancelledErrors that bubble up from the given coro. This isn't fool-proof: if the user doesn't provide a coro, and instead creates their own with loop.create_task, that task might bubble a CancelledError into the run_until_complete().""" try: await coro except asyncio.CancelledError: pass loop.create_task(new_coro()) shutdown_handler = shutdown_handler or _shutdown_handler if WINDOWS: # pragma: no cover # This is to allow CTRL-C to be detected in a timely fashion, # see: https://bugs.python.org/issue23057#msg246316 loop.create_task(windows_support_wakeup()) # This is to be able to handle SIGBREAK. def windows_handler(sig, frame): # Disable the handler so it won't be called again. signame = signal.Signals(sig).name logger.critical('Received signal: %s. Stopping the loop.', signame) shutdown_handler(loop) signal.signal(signal.SIGBREAK, windows_handler) signal.signal(signal.SIGINT, windows_handler) else: loop.add_signal_handler(SIGINT, shutdown_handler, loop) loop.add_signal_handler(SIGTERM, shutdown_handler, loop) # TODO: We probably don't want to create a different executor if the # TODO: loop was supplied. (User might have put stuff on that loop's # TODO: executor). if not executor: logger.debug('Creating default executor') executor = ThreadPoolExecutor(max_workers=executor_workers) loop.set_default_executor(executor) try: loop.run_forever() except KeyboardInterrupt: # pragma: no cover logger.info('Got KeyboardInterrupt') if WINDOWS: # Windows doesn't do any POSIX signal handling, and no # abstraction layer for signals is currently implemented in # asyncio. So we fall back to KeyboardInterrupt (triggered # by the user/environment sending CTRL-C, or signal.CTRL_C_EVENT shutdown_handler() logger.info('Entering shutdown phase.') def sep(): tasks = all_tasks(loop=loop) do_not_cancel = set() for t in tasks: # TODO: we don't need access to the coro. We could simply # TODO: store the task itself in the weakset. if t._coro in _DO_NOT_CANCEL_COROS: do_not_cancel.add(t) tasks -= do_not_cancel logger.info('Cancelling pending tasks.') for t in tasks: logger.debug('Cancelling task: %s', t) t.cancel() return tasks, do_not_cancel tasks, do_not_cancel = sep() # Here's a protip: if you group a bunch of tasks, and some of them # get cancelled, and they DON'T HANDLE THE CANCELLATION, then the # raised CancelledError will bubble up to, and stop the # loop.run_until_complete() line: meaning, not all the tasks in # the gathered group will actually be complete. You need to # enable this with the ``return_exceptions`` flag. group = gather(*tasks, *do_not_cancel, return_exceptions=True) logger.info('Running pending tasks till complete') # TODO: obtain all the results, and log any results that are exceptions # other than CancelledError. Will be useful for troubleshooting. loop.run_until_complete(group) logger.info('Waiting for executor shutdown.') executor.shutdown(wait=True) # If loop was supplied, it's up to the caller to close! if not loop_was_supplied: logger.info('Closing the loop.') loop.close() logger.critical('Leaving. Bye!')
[ "def", "run", "(", "coro", ":", "'Optional[Coroutine]'", "=", "None", ",", "*", ",", "loop", ":", "Optional", "[", "AbstractEventLoop", "]", "=", "None", ",", "shutdown_handler", ":", "Optional", "[", "Callable", "[", "[", "AbstractEventLoop", "]", ",", "None", "]", "]", "=", "None", ",", "executor_workers", ":", "int", "=", "10", ",", "executor", ":", "Optional", "[", "Executor", "]", "=", "None", ",", "use_uvloop", ":", "bool", "=", "False", ")", "->", "None", ":", "logger", ".", "debug", "(", "'Entering run()'", ")", "assert", "not", "(", "loop", "and", "use_uvloop", ")", ",", "(", "\"'loop' and 'use_uvloop' parameters are mutually \"", "\"exclusive. (Just make your own uvloop and pass it in).\"", ")", "if", "use_uvloop", ":", "import", "uvloop", "asyncio", ".", "set_event_loop_policy", "(", "uvloop", ".", "EventLoopPolicy", "(", ")", ")", "loop_was_supplied", "=", "bool", "(", "loop", ")", "if", "not", "loop_was_supplied", ":", "loop", "=", "get_event_loop", "(", ")", "if", "coro", ":", "async", "def", "new_coro", "(", ")", ":", "\"\"\"During shutdown, run_until_complete() will exit\n if a CancelledError bubbles up from anything in the\n group. To counteract that, we'll try to handle\n any CancelledErrors that bubble up from the given\n coro. This isn't fool-proof: if the user doesn't\n provide a coro, and instead creates their own with\n loop.create_task, that task might bubble\n a CancelledError into the run_until_complete().\"\"\"", "try", ":", "await", "coro", "except", "asyncio", ".", "CancelledError", ":", "pass", "loop", ".", "create_task", "(", "new_coro", "(", ")", ")", "shutdown_handler", "=", "shutdown_handler", "or", "_shutdown_handler", "if", "WINDOWS", ":", "# pragma: no cover", "# This is to allow CTRL-C to be detected in a timely fashion,", "# see: https://bugs.python.org/issue23057#msg246316", "loop", ".", "create_task", "(", "windows_support_wakeup", "(", ")", ")", "# This is to be able to handle SIGBREAK.", "def", "windows_handler", "(", "sig", ",", "frame", ")", ":", "# Disable the handler so it won't be called again.", "signame", "=", "signal", ".", "Signals", "(", "sig", ")", ".", "name", "logger", ".", "critical", "(", "'Received signal: %s. Stopping the loop.'", ",", "signame", ")", "shutdown_handler", "(", "loop", ")", "signal", ".", "signal", "(", "signal", ".", "SIGBREAK", ",", "windows_handler", ")", "signal", ".", "signal", "(", "signal", ".", "SIGINT", ",", "windows_handler", ")", "else", ":", "loop", ".", "add_signal_handler", "(", "SIGINT", ",", "shutdown_handler", ",", "loop", ")", "loop", ".", "add_signal_handler", "(", "SIGTERM", ",", "shutdown_handler", ",", "loop", ")", "# TODO: We probably don't want to create a different executor if the", "# TODO: loop was supplied. (User might have put stuff on that loop's", "# TODO: executor).", "if", "not", "executor", ":", "logger", ".", "debug", "(", "'Creating default executor'", ")", "executor", "=", "ThreadPoolExecutor", "(", "max_workers", "=", "executor_workers", ")", "loop", ".", "set_default_executor", "(", "executor", ")", "try", ":", "loop", ".", "run_forever", "(", ")", "except", "KeyboardInterrupt", ":", "# pragma: no cover", "logger", ".", "info", "(", "'Got KeyboardInterrupt'", ")", "if", "WINDOWS", ":", "# Windows doesn't do any POSIX signal handling, and no", "# abstraction layer for signals is currently implemented in", "# asyncio. So we fall back to KeyboardInterrupt (triggered", "# by the user/environment sending CTRL-C, or signal.CTRL_C_EVENT", "shutdown_handler", "(", ")", "logger", ".", "info", "(", "'Entering shutdown phase.'", ")", "def", "sep", "(", ")", ":", "tasks", "=", "all_tasks", "(", "loop", "=", "loop", ")", "do_not_cancel", "=", "set", "(", ")", "for", "t", "in", "tasks", ":", "# TODO: we don't need access to the coro. We could simply", "# TODO: store the task itself in the weakset.", "if", "t", ".", "_coro", "in", "_DO_NOT_CANCEL_COROS", ":", "do_not_cancel", ".", "add", "(", "t", ")", "tasks", "-=", "do_not_cancel", "logger", ".", "info", "(", "'Cancelling pending tasks.'", ")", "for", "t", "in", "tasks", ":", "logger", ".", "debug", "(", "'Cancelling task: %s'", ",", "t", ")", "t", ".", "cancel", "(", ")", "return", "tasks", ",", "do_not_cancel", "tasks", ",", "do_not_cancel", "=", "sep", "(", ")", "# Here's a protip: if you group a bunch of tasks, and some of them", "# get cancelled, and they DON'T HANDLE THE CANCELLATION, then the", "# raised CancelledError will bubble up to, and stop the", "# loop.run_until_complete() line: meaning, not all the tasks in", "# the gathered group will actually be complete. You need to", "# enable this with the ``return_exceptions`` flag.", "group", "=", "gather", "(", "*", "tasks", ",", "*", "do_not_cancel", ",", "return_exceptions", "=", "True", ")", "logger", ".", "info", "(", "'Running pending tasks till complete'", ")", "# TODO: obtain all the results, and log any results that are exceptions", "# other than CancelledError. Will be useful for troubleshooting.", "loop", ".", "run_until_complete", "(", "group", ")", "logger", ".", "info", "(", "'Waiting for executor shutdown.'", ")", "executor", ".", "shutdown", "(", "wait", "=", "True", ")", "# If loop was supplied, it's up to the caller to close!", "if", "not", "loop_was_supplied", ":", "logger", ".", "info", "(", "'Closing the loop.'", ")", "loop", ".", "close", "(", ")", "logger", ".", "critical", "(", "'Leaving. Bye!'", ")" ]
Start up the event loop, and wait for a signal to shut down. :param coro: Optionally supply a coroutine. The loop will still run if missing. The loop will continue to run after the supplied coroutine finishes. The supplied coroutine is typically a "main" coroutine from which all other work is spawned. :param loop: Optionally supply your own loop. If missing, the default loop attached to the current thread context will be used, i.e., whatever ``asyncio.get_event_loop()`` returns. :param shutdown_handler: By default, SIGINT and SIGTERM will be handled and will stop the loop, thereby invoking the shutdown sequence. Alternatively you can supply your own shutdown handler function. It should conform to the type spec as shown in the function signature. :param executor_workers: The number of workers in the executor. (NOTE: ``run()`` creates a new executor instance internally, regardless of whether you supply your own loop.) :param executor: You can decide to use your own executor instance if you like. :param use_uvloop: The loop policy will be set to use uvloop. It is your responsibility to install uvloop. If missing, an ``ImportError`` will be raised.
[ "Start", "up", "the", "event", "loop", "and", "wait", "for", "a", "signal", "to", "shut", "down", "." ]
23c73318447f578a4a24845c5f43574ac7b414e4
https://github.com/cjrh/aiorun/blob/23c73318447f578a4a24845c5f43574ac7b414e4/aiorun.py#L120-L255
train
emre/storm
storm/kommandr.py
prog.command
def command(self, *args, **kwargs): """Convenient decorator simply creates corresponding command""" if len(args) == 1 and isinstance(args[0], collections.Callable): return self._generate_command(args[0]) else: def _command(func): return self._generate_command(func, *args, **kwargs) return _command
python
def command(self, *args, **kwargs): """Convenient decorator simply creates corresponding command""" if len(args) == 1 and isinstance(args[0], collections.Callable): return self._generate_command(args[0]) else: def _command(func): return self._generate_command(func, *args, **kwargs) return _command
[ "def", "command", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "len", "(", "args", ")", "==", "1", "and", "isinstance", "(", "args", "[", "0", "]", ",", "collections", ".", "Callable", ")", ":", "return", "self", ".", "_generate_command", "(", "args", "[", "0", "]", ")", "else", ":", "def", "_command", "(", "func", ")", ":", "return", "self", ".", "_generate_command", "(", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "_command" ]
Convenient decorator simply creates corresponding command
[ "Convenient", "decorator", "simply", "creates", "corresponding", "command" ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/kommandr.py#L96-L103
train
emre/storm
storm/kommandr.py
prog._generate_command
def _generate_command(self, func, name=None, **kwargs): """Generates a command parser for given func. :param func: func to generate related command parser :param type: function :param name: command name :param type: str :param **kwargs: keyword arguments those passed through to :py:class:``argparse.ArgumentParser.add_parser`` :param type: dict """ func_pointer = name or func.__name__ storm_config = get_storm_config() aliases, additional_kwarg = None, None if 'aliases' in storm_config: for command, alias_list in \ six.iteritems(storm_config.get("aliases")): if func_pointer == command: aliases = alias_list break func_help = func.__doc__ and func.__doc__.strip() subparser = self.subparsers.add_parser(name or func.__name__, aliases=aliases, help=func_help) spec = inspect.getargspec(func) opts = reversed(list(izip_longest(reversed(spec.args or []), reversed(spec.defaults or []), fillvalue=self._POSITIONAL()))) for k, v in opts: argopts = getattr(func, 'argopts', {}) args, kwargs = argopts.get(k, ([], {})) args = list(args) is_positional = isinstance(v, self._POSITIONAL) options = [arg for arg in args if arg.startswith('-')] if isinstance(v, list): kwargs.update({ 'action': 'append', }) if is_positional: if options: args = options kwargs.update({'required': True, 'dest': k}) else: args = [k] else: args = options or ['--%s' % k] kwargs.update({'default': v, 'dest': k}) arg = subparser.add_argument(*args, **kwargs) subparser.set_defaults(**{self._COMMAND_FLAG: func}) return func
python
def _generate_command(self, func, name=None, **kwargs): """Generates a command parser for given func. :param func: func to generate related command parser :param type: function :param name: command name :param type: str :param **kwargs: keyword arguments those passed through to :py:class:``argparse.ArgumentParser.add_parser`` :param type: dict """ func_pointer = name or func.__name__ storm_config = get_storm_config() aliases, additional_kwarg = None, None if 'aliases' in storm_config: for command, alias_list in \ six.iteritems(storm_config.get("aliases")): if func_pointer == command: aliases = alias_list break func_help = func.__doc__ and func.__doc__.strip() subparser = self.subparsers.add_parser(name or func.__name__, aliases=aliases, help=func_help) spec = inspect.getargspec(func) opts = reversed(list(izip_longest(reversed(spec.args or []), reversed(spec.defaults or []), fillvalue=self._POSITIONAL()))) for k, v in opts: argopts = getattr(func, 'argopts', {}) args, kwargs = argopts.get(k, ([], {})) args = list(args) is_positional = isinstance(v, self._POSITIONAL) options = [arg for arg in args if arg.startswith('-')] if isinstance(v, list): kwargs.update({ 'action': 'append', }) if is_positional: if options: args = options kwargs.update({'required': True, 'dest': k}) else: args = [k] else: args = options or ['--%s' % k] kwargs.update({'default': v, 'dest': k}) arg = subparser.add_argument(*args, **kwargs) subparser.set_defaults(**{self._COMMAND_FLAG: func}) return func
[ "def", "_generate_command", "(", "self", ",", "func", ",", "name", "=", "None", ",", "*", "*", "kwargs", ")", ":", "func_pointer", "=", "name", "or", "func", ".", "__name__", "storm_config", "=", "get_storm_config", "(", ")", "aliases", ",", "additional_kwarg", "=", "None", ",", "None", "if", "'aliases'", "in", "storm_config", ":", "for", "command", ",", "alias_list", "in", "six", ".", "iteritems", "(", "storm_config", ".", "get", "(", "\"aliases\"", ")", ")", ":", "if", "func_pointer", "==", "command", ":", "aliases", "=", "alias_list", "break", "func_help", "=", "func", ".", "__doc__", "and", "func", ".", "__doc__", ".", "strip", "(", ")", "subparser", "=", "self", ".", "subparsers", ".", "add_parser", "(", "name", "or", "func", ".", "__name__", ",", "aliases", "=", "aliases", ",", "help", "=", "func_help", ")", "spec", "=", "inspect", ".", "getargspec", "(", "func", ")", "opts", "=", "reversed", "(", "list", "(", "izip_longest", "(", "reversed", "(", "spec", ".", "args", "or", "[", "]", ")", ",", "reversed", "(", "spec", ".", "defaults", "or", "[", "]", ")", ",", "fillvalue", "=", "self", ".", "_POSITIONAL", "(", ")", ")", ")", ")", "for", "k", ",", "v", "in", "opts", ":", "argopts", "=", "getattr", "(", "func", ",", "'argopts'", ",", "{", "}", ")", "args", ",", "kwargs", "=", "argopts", ".", "get", "(", "k", ",", "(", "[", "]", ",", "{", "}", ")", ")", "args", "=", "list", "(", "args", ")", "is_positional", "=", "isinstance", "(", "v", ",", "self", ".", "_POSITIONAL", ")", "options", "=", "[", "arg", "for", "arg", "in", "args", "if", "arg", ".", "startswith", "(", "'-'", ")", "]", "if", "isinstance", "(", "v", ",", "list", ")", ":", "kwargs", ".", "update", "(", "{", "'action'", ":", "'append'", ",", "}", ")", "if", "is_positional", ":", "if", "options", ":", "args", "=", "options", "kwargs", ".", "update", "(", "{", "'required'", ":", "True", ",", "'dest'", ":", "k", "}", ")", "else", ":", "args", "=", "[", "k", "]", "else", ":", "args", "=", "options", "or", "[", "'--%s'", "%", "k", "]", "kwargs", ".", "update", "(", "{", "'default'", ":", "v", ",", "'dest'", ":", "k", "}", ")", "arg", "=", "subparser", ".", "add_argument", "(", "*", "args", ",", "*", "*", "kwargs", ")", "subparser", ".", "set_defaults", "(", "*", "*", "{", "self", ".", "_COMMAND_FLAG", ":", "func", "}", ")", "return", "func" ]
Generates a command parser for given func. :param func: func to generate related command parser :param type: function :param name: command name :param type: str :param **kwargs: keyword arguments those passed through to :py:class:``argparse.ArgumentParser.add_parser`` :param type: dict
[ "Generates", "a", "command", "parser", "for", "given", "func", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/kommandr.py#L121-L177
train
emre/storm
storm/kommandr.py
prog.execute
def execute(self, arg_list): """Main function to parse and dispatch commands by given ``arg_list`` :param arg_list: all arguments provided by the command line :param type: list """ arg_map = self.parser.parse_args(arg_list).__dict__ command = arg_map.pop(self._COMMAND_FLAG) return command(**arg_map)
python
def execute(self, arg_list): """Main function to parse and dispatch commands by given ``arg_list`` :param arg_list: all arguments provided by the command line :param type: list """ arg_map = self.parser.parse_args(arg_list).__dict__ command = arg_map.pop(self._COMMAND_FLAG) return command(**arg_map)
[ "def", "execute", "(", "self", ",", "arg_list", ")", ":", "arg_map", "=", "self", ".", "parser", ".", "parse_args", "(", "arg_list", ")", ".", "__dict__", "command", "=", "arg_map", ".", "pop", "(", "self", ".", "_COMMAND_FLAG", ")", "return", "command", "(", "*", "*", "arg_map", ")" ]
Main function to parse and dispatch commands by given ``arg_list`` :param arg_list: all arguments provided by the command line :param type: list
[ "Main", "function", "to", "parse", "and", "dispatch", "commands", "by", "given", "arg_list" ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/kommandr.py#L179-L188
train
emre/storm
storm/__main__.py
add
def add(name, connection_uri, id_file="", o=[], config=None): """ Adds a new entry to sshconfig. """ storm_ = get_storm_instance(config) try: # validate name if '@' in name: raise ValueError('invalid value: "@" cannot be used in name.') user, host, port = parse( connection_uri, user=get_default("user", storm_.defaults), port=get_default("port", storm_.defaults) ) storm_.add_entry(name, host, user, port, id_file, o) print( get_formatted_message( '{0} added to your ssh config. you can connect ' 'it by typing "ssh {0}".'.format(name), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
python
def add(name, connection_uri, id_file="", o=[], config=None): """ Adds a new entry to sshconfig. """ storm_ = get_storm_instance(config) try: # validate name if '@' in name: raise ValueError('invalid value: "@" cannot be used in name.') user, host, port = parse( connection_uri, user=get_default("user", storm_.defaults), port=get_default("port", storm_.defaults) ) storm_.add_entry(name, host, user, port, id_file, o) print( get_formatted_message( '{0} added to your ssh config. you can connect ' 'it by typing "ssh {0}".'.format(name), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
[ "def", "add", "(", "name", ",", "connection_uri", ",", "id_file", "=", "\"\"", ",", "o", "=", "[", "]", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "# validate name", "if", "'@'", "in", "name", ":", "raise", "ValueError", "(", "'invalid value: \"@\" cannot be used in name.'", ")", "user", ",", "host", ",", "port", "=", "parse", "(", "connection_uri", ",", "user", "=", "get_default", "(", "\"user\"", ",", "storm_", ".", "defaults", ")", ",", "port", "=", "get_default", "(", "\"port\"", ",", "storm_", ".", "defaults", ")", ")", "storm_", ".", "add_entry", "(", "name", ",", "host", ",", "user", ",", "port", ",", "id_file", ",", "o", ")", "print", "(", "get_formatted_message", "(", "'{0} added to your ssh config. you can connect '", "'it by typing \"ssh {0}\".'", ".", "format", "(", "name", ")", ",", "'success'", ")", ")", "except", "ValueError", "as", "error", ":", "print", "(", "get_formatted_message", "(", "error", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Adds a new entry to sshconfig.
[ "Adds", "a", "new", "entry", "to", "sshconfig", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L34-L63
train
emre/storm
storm/__main__.py
clone
def clone(name, clone_name, config=None): """ Clone an entry to the sshconfig. """ storm_ = get_storm_instance(config) try: # validate name if '@' in name: raise ValueError('invalid value: "@" cannot be used in name.') storm_.clone_entry(name, clone_name) print( get_formatted_message( '{0} added to your ssh config. you can connect ' 'it by typing "ssh {0}".'.format(clone_name), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
python
def clone(name, clone_name, config=None): """ Clone an entry to the sshconfig. """ storm_ = get_storm_instance(config) try: # validate name if '@' in name: raise ValueError('invalid value: "@" cannot be used in name.') storm_.clone_entry(name, clone_name) print( get_formatted_message( '{0} added to your ssh config. you can connect ' 'it by typing "ssh {0}".'.format(clone_name), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
[ "def", "clone", "(", "name", ",", "clone_name", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "# validate name", "if", "'@'", "in", "name", ":", "raise", "ValueError", "(", "'invalid value: \"@\" cannot be used in name.'", ")", "storm_", ".", "clone_entry", "(", "name", ",", "clone_name", ")", "print", "(", "get_formatted_message", "(", "'{0} added to your ssh config. you can connect '", "'it by typing \"ssh {0}\".'", ".", "format", "(", "clone_name", ")", ",", "'success'", ")", ")", "except", "ValueError", "as", "error", ":", "print", "(", "get_formatted_message", "(", "error", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Clone an entry to the sshconfig.
[ "Clone", "an", "entry", "to", "the", "sshconfig", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L67-L90
train
emre/storm
storm/__main__.py
move
def move(name, entry_name, config=None): """ Move an entry to the sshconfig. """ storm_ = get_storm_instance(config) try: if '@' in name: raise ValueError('invalid value: "@" cannot be used in name.') storm_.clone_entry(name, entry_name, keep_original=False) print( get_formatted_message( '{0} moved in ssh config. you can ' 'connect it by typing "ssh {0}".'.format( entry_name ), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
python
def move(name, entry_name, config=None): """ Move an entry to the sshconfig. """ storm_ = get_storm_instance(config) try: if '@' in name: raise ValueError('invalid value: "@" cannot be used in name.') storm_.clone_entry(name, entry_name, keep_original=False) print( get_formatted_message( '{0} moved in ssh config. you can ' 'connect it by typing "ssh {0}".'.format( entry_name ), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
[ "def", "move", "(", "name", ",", "entry_name", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "if", "'@'", "in", "name", ":", "raise", "ValueError", "(", "'invalid value: \"@\" cannot be used in name.'", ")", "storm_", ".", "clone_entry", "(", "name", ",", "entry_name", ",", "keep_original", "=", "False", ")", "print", "(", "get_formatted_message", "(", "'{0} moved in ssh config. you can '", "'connect it by typing \"ssh {0}\".'", ".", "format", "(", "entry_name", ")", ",", "'success'", ")", ")", "except", "ValueError", "as", "error", ":", "print", "(", "get_formatted_message", "(", "error", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Move an entry to the sshconfig.
[ "Move", "an", "entry", "to", "the", "sshconfig", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L93-L117
train
emre/storm
storm/__main__.py
edit
def edit(name, connection_uri, id_file="", o=[], config=None): """ Edits the related entry in ssh config. """ storm_ = get_storm_instance(config) try: if ',' in name: name = " ".join(name.split(",")) user, host, port = parse( connection_uri, user=get_default("user", storm_.defaults), port=get_default("port", storm_.defaults) ) storm_.edit_entry(name, host, user, port, id_file, o) print(get_formatted_message( '"{0}" updated successfully.'.format( name ), 'success')) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
python
def edit(name, connection_uri, id_file="", o=[], config=None): """ Edits the related entry in ssh config. """ storm_ = get_storm_instance(config) try: if ',' in name: name = " ".join(name.split(",")) user, host, port = parse( connection_uri, user=get_default("user", storm_.defaults), port=get_default("port", storm_.defaults) ) storm_.edit_entry(name, host, user, port, id_file, o) print(get_formatted_message( '"{0}" updated successfully.'.format( name ), 'success')) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
[ "def", "edit", "(", "name", ",", "connection_uri", ",", "id_file", "=", "\"\"", ",", "o", "=", "[", "]", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "if", "','", "in", "name", ":", "name", "=", "\" \"", ".", "join", "(", "name", ".", "split", "(", "\",\"", ")", ")", "user", ",", "host", ",", "port", "=", "parse", "(", "connection_uri", ",", "user", "=", "get_default", "(", "\"user\"", ",", "storm_", ".", "defaults", ")", ",", "port", "=", "get_default", "(", "\"port\"", ",", "storm_", ".", "defaults", ")", ")", "storm_", ".", "edit_entry", "(", "name", ",", "host", ",", "user", ",", "port", ",", "id_file", ",", "o", ")", "print", "(", "get_formatted_message", "(", "'\"{0}\" updated successfully.'", ".", "format", "(", "name", ")", ",", "'success'", ")", ")", "except", "ValueError", "as", "error", ":", "print", "(", "get_formatted_message", "(", "error", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Edits the related entry in ssh config.
[ "Edits", "the", "related", "entry", "in", "ssh", "config", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L120-L143
train
emre/storm
storm/__main__.py
update
def update(name, connection_uri="", id_file="", o=[], config=None): """ Enhanced version of the edit command featuring multiple edits using regular expressions to match entries """ storm_ = get_storm_instance(config) settings = {} if id_file != "": settings['identityfile'] = id_file for option in o: k, v = option.split("=") settings[k] = v try: storm_.update_entry(name, **settings) print(get_formatted_message( '"{0}" updated successfully.'.format( name ), 'success')) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
python
def update(name, connection_uri="", id_file="", o=[], config=None): """ Enhanced version of the edit command featuring multiple edits using regular expressions to match entries """ storm_ = get_storm_instance(config) settings = {} if id_file != "": settings['identityfile'] = id_file for option in o: k, v = option.split("=") settings[k] = v try: storm_.update_entry(name, **settings) print(get_formatted_message( '"{0}" updated successfully.'.format( name ), 'success')) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
[ "def", "update", "(", "name", ",", "connection_uri", "=", "\"\"", ",", "id_file", "=", "\"\"", ",", "o", "=", "[", "]", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "settings", "=", "{", "}", "if", "id_file", "!=", "\"\"", ":", "settings", "[", "'identityfile'", "]", "=", "id_file", "for", "option", "in", "o", ":", "k", ",", "v", "=", "option", ".", "split", "(", "\"=\"", ")", "settings", "[", "k", "]", "=", "v", "try", ":", "storm_", ".", "update_entry", "(", "name", ",", "*", "*", "settings", ")", "print", "(", "get_formatted_message", "(", "'\"{0}\" updated successfully.'", ".", "format", "(", "name", ")", ",", "'success'", ")", ")", "except", "ValueError", "as", "error", ":", "print", "(", "get_formatted_message", "(", "error", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Enhanced version of the edit command featuring multiple edits using regular expressions to match entries
[ "Enhanced", "version", "of", "the", "edit", "command", "featuring", "multiple", "edits", "using", "regular", "expressions", "to", "match", "entries" ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L146-L169
train
emre/storm
storm/__main__.py
delete
def delete(name, config=None): """ Deletes a single host. """ storm_ = get_storm_instance(config) try: storm_.delete_entry(name) print( get_formatted_message( 'hostname "{0}" deleted successfully.'.format(name), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
python
def delete(name, config=None): """ Deletes a single host. """ storm_ = get_storm_instance(config) try: storm_.delete_entry(name) print( get_formatted_message( 'hostname "{0}" deleted successfully.'.format(name), 'success') ) except ValueError as error: print(get_formatted_message(error, 'error'), file=sys.stderr) sys.exit(1)
[ "def", "delete", "(", "name", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "storm_", ".", "delete_entry", "(", "name", ")", "print", "(", "get_formatted_message", "(", "'hostname \"{0}\" deleted successfully.'", ".", "format", "(", "name", ")", ",", "'success'", ")", ")", "except", "ValueError", "as", "error", ":", "print", "(", "get_formatted_message", "(", "error", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Deletes a single host.
[ "Deletes", "a", "single", "host", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L172-L187
train
emre/storm
storm/__main__.py
list
def list(config=None): """ Lists all hosts from ssh config. """ storm_ = get_storm_instance(config) try: result = colored('Listing entries:', 'white', attrs=["bold", ]) + "\n\n" result_stack = "" for host in storm_.list_entries(True): if host.get("type") == 'entry': if not host.get("host") == "*": result += " {0} -> {1}@{2}:{3}".format( colored(host["host"], 'green', attrs=["bold", ]), host.get("options").get( "user", get_default("user", storm_.defaults) ), host.get("options").get( "hostname", "[hostname_not_specified]" ), host.get("options").get( "port", get_default("port", storm_.defaults) ) ) extra = False for key, value in six.iteritems(host.get("options")): if not key in ["user", "hostname", "port"]: if not extra: custom_options = colored( '\n\t[custom options] ', 'white' ) result += " {0}".format(custom_options) extra = True if isinstance(value, collections.Sequence): if isinstance(value, builtins.list): value = ",".join(value) result += "{0}={1} ".format(key, value) if extra: result = result[0:-1] result += "\n\n" else: result_stack = colored( " (*) General options: \n", "green", attrs=["bold",] ) for key, value in six.iteritems(host.get("options")): if isinstance(value, type([])): result_stack += "\t {0}: ".format( colored(key, "magenta") ) result_stack += ', '.join(value) result_stack += "\n" else: result_stack += "\t {0}: {1}\n".format( colored(key, "magenta"), value, ) result_stack = result_stack[0:-1] + "\n" result += result_stack print(get_formatted_message(result, "")) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
python
def list(config=None): """ Lists all hosts from ssh config. """ storm_ = get_storm_instance(config) try: result = colored('Listing entries:', 'white', attrs=["bold", ]) + "\n\n" result_stack = "" for host in storm_.list_entries(True): if host.get("type") == 'entry': if not host.get("host") == "*": result += " {0} -> {1}@{2}:{3}".format( colored(host["host"], 'green', attrs=["bold", ]), host.get("options").get( "user", get_default("user", storm_.defaults) ), host.get("options").get( "hostname", "[hostname_not_specified]" ), host.get("options").get( "port", get_default("port", storm_.defaults) ) ) extra = False for key, value in six.iteritems(host.get("options")): if not key in ["user", "hostname", "port"]: if not extra: custom_options = colored( '\n\t[custom options] ', 'white' ) result += " {0}".format(custom_options) extra = True if isinstance(value, collections.Sequence): if isinstance(value, builtins.list): value = ",".join(value) result += "{0}={1} ".format(key, value) if extra: result = result[0:-1] result += "\n\n" else: result_stack = colored( " (*) General options: \n", "green", attrs=["bold",] ) for key, value in six.iteritems(host.get("options")): if isinstance(value, type([])): result_stack += "\t {0}: ".format( colored(key, "magenta") ) result_stack += ', '.join(value) result_stack += "\n" else: result_stack += "\t {0}: {1}\n".format( colored(key, "magenta"), value, ) result_stack = result_stack[0:-1] + "\n" result += result_stack print(get_formatted_message(result, "")) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
[ "def", "list", "(", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "result", "=", "colored", "(", "'Listing entries:'", ",", "'white'", ",", "attrs", "=", "[", "\"bold\"", ",", "]", ")", "+", "\"\\n\\n\"", "result_stack", "=", "\"\"", "for", "host", "in", "storm_", ".", "list_entries", "(", "True", ")", ":", "if", "host", ".", "get", "(", "\"type\"", ")", "==", "'entry'", ":", "if", "not", "host", ".", "get", "(", "\"host\"", ")", "==", "\"*\"", ":", "result", "+=", "\" {0} -> {1}@{2}:{3}\"", ".", "format", "(", "colored", "(", "host", "[", "\"host\"", "]", ",", "'green'", ",", "attrs", "=", "[", "\"bold\"", ",", "]", ")", ",", "host", ".", "get", "(", "\"options\"", ")", ".", "get", "(", "\"user\"", ",", "get_default", "(", "\"user\"", ",", "storm_", ".", "defaults", ")", ")", ",", "host", ".", "get", "(", "\"options\"", ")", ".", "get", "(", "\"hostname\"", ",", "\"[hostname_not_specified]\"", ")", ",", "host", ".", "get", "(", "\"options\"", ")", ".", "get", "(", "\"port\"", ",", "get_default", "(", "\"port\"", ",", "storm_", ".", "defaults", ")", ")", ")", "extra", "=", "False", "for", "key", ",", "value", "in", "six", ".", "iteritems", "(", "host", ".", "get", "(", "\"options\"", ")", ")", ":", "if", "not", "key", "in", "[", "\"user\"", ",", "\"hostname\"", ",", "\"port\"", "]", ":", "if", "not", "extra", ":", "custom_options", "=", "colored", "(", "'\\n\\t[custom options] '", ",", "'white'", ")", "result", "+=", "\" {0}\"", ".", "format", "(", "custom_options", ")", "extra", "=", "True", "if", "isinstance", "(", "value", ",", "collections", ".", "Sequence", ")", ":", "if", "isinstance", "(", "value", ",", "builtins", ".", "list", ")", ":", "value", "=", "\",\"", ".", "join", "(", "value", ")", "result", "+=", "\"{0}={1} \"", ".", "format", "(", "key", ",", "value", ")", "if", "extra", ":", "result", "=", "result", "[", "0", ":", "-", "1", "]", "result", "+=", "\"\\n\\n\"", "else", ":", "result_stack", "=", "colored", "(", "\" (*) General options: \\n\"", ",", "\"green\"", ",", "attrs", "=", "[", "\"bold\"", ",", "]", ")", "for", "key", ",", "value", "in", "six", ".", "iteritems", "(", "host", ".", "get", "(", "\"options\"", ")", ")", ":", "if", "isinstance", "(", "value", ",", "type", "(", "[", "]", ")", ")", ":", "result_stack", "+=", "\"\\t {0}: \"", ".", "format", "(", "colored", "(", "key", ",", "\"magenta\"", ")", ")", "result_stack", "+=", "', '", ".", "join", "(", "value", ")", "result_stack", "+=", "\"\\n\"", "else", ":", "result_stack", "+=", "\"\\t {0}: {1}\\n\"", ".", "format", "(", "colored", "(", "key", ",", "\"magenta\"", ")", ",", "value", ",", ")", "result_stack", "=", "result_stack", "[", "0", ":", "-", "1", "]", "+", "\"\\n\"", "result", "+=", "result_stack", "print", "(", "get_formatted_message", "(", "result", ",", "\"\"", ")", ")", "except", "Exception", "as", "error", ":", "print", "(", "get_formatted_message", "(", "str", "(", "error", ")", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Lists all hosts from ssh config.
[ "Lists", "all", "hosts", "from", "ssh", "config", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L190-L258
train
emre/storm
storm/__main__.py
search
def search(search_text, config=None): """ Searches entries by given search text. """ storm_ = get_storm_instance(config) try: results = storm_.search_host(search_text) if len(results) == 0: print ('no results found.') if len(results) > 0: message = 'Listing results for {0}:\n'.format(search_text) message += "".join(results) print(message) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
python
def search(search_text, config=None): """ Searches entries by given search text. """ storm_ = get_storm_instance(config) try: results = storm_.search_host(search_text) if len(results) == 0: print ('no results found.') if len(results) > 0: message = 'Listing results for {0}:\n'.format(search_text) message += "".join(results) print(message) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
[ "def", "search", "(", "search_text", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "results", "=", "storm_", ".", "search_host", "(", "search_text", ")", "if", "len", "(", "results", ")", "==", "0", ":", "print", "(", "'no results found.'", ")", "if", "len", "(", "results", ")", ">", "0", ":", "message", "=", "'Listing results for {0}:\\n'", ".", "format", "(", "search_text", ")", "message", "+=", "\"\"", ".", "join", "(", "results", ")", "print", "(", "message", ")", "except", "Exception", "as", "error", ":", "print", "(", "get_formatted_message", "(", "str", "(", "error", ")", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Searches entries by given search text.
[ "Searches", "entries", "by", "given", "search", "text", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L261-L278
train
emre/storm
storm/__main__.py
delete_all
def delete_all(config=None): """ Deletes all hosts from ssh config. """ storm_ = get_storm_instance(config) try: storm_.delete_all_entries() print(get_formatted_message('all entries deleted.', 'success')) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
python
def delete_all(config=None): """ Deletes all hosts from ssh config. """ storm_ = get_storm_instance(config) try: storm_.delete_all_entries() print(get_formatted_message('all entries deleted.', 'success')) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
[ "def", "delete_all", "(", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "storm_", ".", "delete_all_entries", "(", ")", "print", "(", "get_formatted_message", "(", "'all entries deleted.'", ",", "'success'", ")", ")", "except", "Exception", "as", "error", ":", "print", "(", "get_formatted_message", "(", "str", "(", "error", ")", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Deletes all hosts from ssh config.
[ "Deletes", "all", "hosts", "from", "ssh", "config", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L281-L292
train
emre/storm
storm/__main__.py
backup
def backup(target_file, config=None): """ Backups the main ssh configuration into target file. """ storm_ = get_storm_instance(config) try: storm_.backup(target_file) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
python
def backup(target_file, config=None): """ Backups the main ssh configuration into target file. """ storm_ = get_storm_instance(config) try: storm_.backup(target_file) except Exception as error: print(get_formatted_message(str(error), 'error'), file=sys.stderr) sys.exit(1)
[ "def", "backup", "(", "target_file", ",", "config", "=", "None", ")", ":", "storm_", "=", "get_storm_instance", "(", "config", ")", "try", ":", "storm_", ".", "backup", "(", "target_file", ")", "except", "Exception", "as", "error", ":", "print", "(", "get_formatted_message", "(", "str", "(", "error", ")", ",", "'error'", ")", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "1", ")" ]
Backups the main ssh configuration into target file.
[ "Backups", "the", "main", "ssh", "configuration", "into", "target", "file", "." ]
c752defc1b718cfffbf0e0e15532fa1d7840bf6d
https://github.com/emre/storm/blob/c752defc1b718cfffbf0e0e15532fa1d7840bf6d/storm/__main__.py#L295-L304
train