Datasets:

---

jqop

/

python-code-dataset

like 0

[ "def", "calculate_subscription_lifecycle", "(", "subscription_id", ")", ":", "subscription", "=", "Subscription", ".", "objects", ".", "select_related", "(", "\"messageset\"", ",", "\"schedule\"", ")", ".", "get", "(", "id", "=", "subscription_id", ")", "behind", "=", "subscription", ".", "messages_behind", "(", ")", "if", "behind", "==", "0", ":", "return", "current_messageset", "=", "subscription", ".", "messageset", "current_sequence_number", "=", "subscription", ".", "next_sequence_number", "end_subscription", "=", "Subscription", ".", "fast_forward_lifecycle", "(", "subscription", ",", "save", "=", "False", ")", "[", "-", "1", "]", "BehindSubscription", ".", "objects", ".", "create", "(", "subscription", "=", "subscription", ",", "messages_behind", "=", "behind", ",", "current_messageset", "=", "current_messageset", ",", "current_sequence_number", "=", "current_sequence_number", ",", "expected_messageset", "=", "end_subscription", ".", "messageset", ",", "expected_sequence_number", "=", "end_subscription", ".", "next_sequence_number", ",", ")" ]

[ "Calculates", "the", "expected", "lifecycle", "position", "the", "subscription", "in", "subscription_ids", "and", "creates", "a", "BehindSubscription", "entry", "for", "them", "." ]

[ "def", "find_behind_subscriptions", "(", ")", ":", "subscriptions", "=", "Subscription", ".", "objects", ".", "filter", "(", "active", "=", "True", ",", "completed", "=", "False", ",", "process_status", "=", "0", ")", ".", "values_list", "(", "\"id\"", ",", "flat", "=", "True", ")", "for", "subscription_id", "in", "subscriptions", ".", "iterator", "(", ")", ":", "calculate_subscription_lifecycle", ".", "delay", "(", "str", "(", "subscription_id", ")", ")" ]

[ "Finds", "any", "subscriptions", "that", "are", "behind", "according", "to", "where", "they", "should", "be", "and", "creates", "a", "BehindSubscription", "entry", "for", "them", "." ]

[ "def", "send", "(", "self", ",", "request", ",", "pk", "=", "None", ")", ":", "schedule", "=", "self", ".", "get_object", "(", ")", "queue_subscription_send", ".", "delay", "(", "str", "(", "schedule", ".", "id", ")", ")", "return", "Response", "(", "{", "}", ",", "status", "=", "status", ".", "HTTP_202_ACCEPTED", ")" ]

[ "Sends", "all", "the", "subscriptions", "for", "the", "specified", "schedule" ]

[ "def", "get", "(", "self", ",", "key", ":", "Any", ",", "default", ":", "Any", "=", "None", ")", "->", "Any", ":", "return", "self", ".", "data", ".", "get", "(", "key", ",", "default", ")" ]

[ "Return", "the", "configured", "value", "for", "the", "given", "key", "name", "or", "default", "if", "no", "value", "is", "available", "or", "key", "is", "invalid", "." ]

[ "def", "task_config", "(", "self", ",", "task", ":", "Task", ")", "->", "Any", ":", "return", "self", ".", "get", "(", "task", ".", "__class__", ".", "__name__", ")" ]

[ "Return", "the", "task", "-", "specific", "configuration", "." ]

[ "async", "def", "init", "(", "self", ")", "->", "None", ":", "if", "self", ".", "data", ":", "return", "if", "self", ".", "json_data", ":", "try", ":", "self", ".", "data", "=", "json", ".", "loads", "(", "self", ".", "json_data", ")", "except", "Exception", ":", "Log", ".", "exception", "(", "'Falied to load raw configuration'", ")", "else", ":", "try", ":", "with", "open", "(", "self", ".", "json_path", ",", "'r'", ")", "as", "f", ":", "self", ".", "data", "=", "json", ".", "load", "(", "f", ")", "except", "Exception", ":", "Log", ".", "exception", "(", "'Failed to load configuration from %s'", ",", "self", ".", "json_path", ")", "self", ".", "data", "=", "{", "}" ]

[ "Load", "configuration", "in", "JSON", "format", "from", "either", "a", "file", "or", "a", "raw", "data", "string", "." ]

[ "async", "def", "run_task", "(", "self", ")", "->", "None", ":", "self", ".", "last_run", "=", "0.0", "self", ".", "target", "=", "self", ".", "time", "(", ")", "+", "self", ".", "DELAY", "while", "self", ".", "running", ":", "try", ":", "now", "=", "self", ".", "time", "(", ")", "if", "now", "<", "self", ".", "target", ":", "sleep", "=", "self", ".", "target", "-", "now", "await", "self", ".", "sleep", "(", "sleep", ")", "elif", "self", ".", "last_run", "<", "self", ".", "target", ":", "Log", ".", "debug", "(", "'executing timer task %s'", ",", "self", ".", "name", ")", "self", ".", "last_run", "=", "self", ".", "time", "(", ")", "await", "self", ".", "run", "(", ")", "total", "=", "self", ".", "time", "(", ")", "-", "self", ".", "last_run", "Log", ".", "debug", "(", "'finished timer task %s in %.1f seconds'", ",", "self", ".", "name", ",", "total", ")", "else", ":", "sleep", "=", "min", "(", "5.0", ",", "self", ".", "DELAY", ")", "await", "self", ".", "sleep", "(", "sleep", ")", "except", "CancelledError", ":", "Log", ".", "debug", "(", "'cancelled timer task %s'", ",", "self", ".", "name", ")", "raise", "except", "Exception", ":", "Log", ".", "exception", "(", "'exception in timer task %s'", ",", "self", ".", "name", ")" ]

[ "Execute", "the", "task", "inside", "the", "asyncio", "event", "loop", "after", "DELAY", "seconds", ".", "Track", "the", "time", "it", "takes", "to", "run", "and", "log", "when", "it", "starts", "/", "stops", ".", "If", "/", "when", "reset", "()", "is", "called", "reset", "the", "wait", "time", "to", "DELAY", "seconds", "." ]

[ "def", "reset", "(", "self", ")", "->", "None", ":", "Log", ".", "debug", "(", "'resetting timer task %s'", ")", "self", ".", "target", "=", "self", ".", "time", "(", ")", "+", "self", ".", "DELAY" ]

[ "Reset", "task", "execution", "to", "DELAY", "seconds", "from", "now", "." ]

[ "def", "internal_only", "(", "view_func", ")", ":", "@", "functools", ".", "wraps", "(", "view_func", ")", "def", "wrapper", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "forwards", "=", "request", ".", "META", ".", "get", "(", "\"HTTP_X_FORWARDED_FOR\"", ",", "\"\"", ")", ".", "split", "(", "\",\"", ")", "# The nginx in the docker container adds the loadbalancer IP to the list inside", "# X-Forwarded-For, so if the list contains more than a single item, we know", "# that it went through our loadbalancer", "if", "len", "(", "forwards", ")", ">", "1", ":", "raise", "PermissionDenied", "(", ")", "return", "view_func", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "wrapper" ]

[ "A", "view", "decorator", "which", "blocks", "access", "for", "requests", "coming", "through", "the", "load", "balancer", "." ]

[ "def", "post", "(", "self", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "schedule_disable", ".", "delay", "(", "kwargs", "[", "\"subscription_id\"", "]", ")", "return", "Response", "(", "{", "\"accepted\"", ":", "True", "}", ",", "status", "=", "201", ")" ]

[ "Validates", "subscription", "data", "before", "creating", "Outbound", "message" ]

[ "def", "post", "(", "self", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# Look up subscriber", "subscription_id", "=", "kwargs", "[", "\"subscription_id\"", "]", "if", "Subscription", ".", "objects", ".", "filter", "(", "id", "=", "subscription_id", ")", ".", "exists", "(", ")", ":", "status", "=", "202", "accepted", "=", "{", "\"accepted\"", ":", "True", "}", "store_resend_request", ".", "apply_async", "(", "args", "=", "[", "subscription_id", "]", ")", "else", ":", "status", "=", "400", "accepted", "=", "{", "\"accepted\"", ":", "False", ",", "\"reason\"", ":", "\"Cannot find subscription with ID {}\"", ".", "format", "(", "subscription_id", ")", ",", "}", "return", "Response", "(", "accepted", ",", "status", "=", "status", ")" ]

[ "Validates", "subscription", "data", "before", "creating", "Outbound", "message" ]

[ "def", "post", "(", "self", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# Ensure that we check for the 'data' key in the request object before", "# attempting to reference it", "if", "\"data\"", "in", "request", ".", "data", ":", "# This is a workaround for JSONField not liking blank/null refs", "if", "\"metadata\"", "not", "in", "request", ".", "data", "[", "\"data\"", "]", ":", "request", ".", "data", "[", "\"data\"", "]", "[", "\"metadata\"", "]", "=", "{", "}", "if", "\"initial_sequence_number\"", "not", "in", "request", ".", "data", "[", "\"data\"", "]", ":", "request", ".", "data", "[", "\"data\"", "]", "[", "\"initial_sequence_number\"", "]", "=", "request", ".", "data", "[", "\"data\"", "]", ".", "get", "(", "\"next_sequence_number\"", ")", "subscription", "=", "SubscriptionSerializer", "(", "data", "=", "request", ".", "data", "[", "\"data\"", "]", ")", "if", "subscription", ".", "is_valid", "(", ")", ":", "subscription", ".", "save", "(", ")", "# Return", "status", "=", "201", "accepted", "=", "{", "\"accepted\"", ":", "True", "}", "return", "Response", "(", "accepted", ",", "status", "=", "status", ")", "else", ":", "status", "=", "400", "return", "Response", "(", "subscription", ".", "errors", ",", "status", "=", "status", ")", "else", ":", "status", "=", "400", "message", "=", "{", "\"data\"", ":", "[", "\"This field is required.\"", "]", "}", "return", "Response", "(", "message", ",", "status", "=", "status", ")" ]

[ "Validates", "subscription", "data", "before", "creating", "Subscription", "message" ]

[ "def", "find_behind_subscriptions", "(", "self", ",", "request", ")", ":", "task_id", "=", "find_behind_subscriptions", ".", "delay", "(", ")", "return", "Response", "(", "{", "\"accepted\"", ":", "True", ",", "\"task_id\"", ":", "str", "(", "task_id", ")", "}", ",", "status", "=", "status", ".", "HTTP_202_ACCEPTED", ")" ]

[ "Starts", "a", "celery", "task", "that", "looks", "through", "active", "subscriptions", "to", "find", "and", "subscriptions", "that", "are", "behind", "where", "they", "should", "be", "and", "adds", "a", "BehindSubscription", "for", "them", "." ]

[ "def", "repl", "(", ")", ":", "while", "True", ":", "try", ":", "sys", ".", "stdout", ".", "write", "(", "\"Type in next query: \\n> \"", ")", "import", "locale", "query_str", "=", "raw_input", "(", ")", ".", "decode", "(", "sys", ".", "stdin", ".", "encoding", "or", "locale", ".", "getpreferredencoding", "(", "True", ")", ")", "except", "KeyboardInterrupt", ":", "break", "if", "u'quit'", "in", "query_str", ":", "break", "print_query_and_parse_tree", "(", "query_str", ")" ]

[ "Read", "-", "Eval", "-", "Print", "-", "Loop", "for", "reading", "the", "query", "printing", "it", "and", "its", "parse", "tree", "." ]

[ "async", "def", "run_task", "(", "self", ")", "->", "None", ":", "while", "self", ".", "running", ":", "try", ":", "item", "=", "self", ".", "QUEUE", ".", "get_nowait", "(", ")", "Log", ".", "debug", "(", "'%s processing work item'", ",", "self", ".", "name", ")", "await", "self", ".", "run", "(", "item", ")", "Log", ".", "debug", "(", "'%s completed work item'", ",", "self", ".", "name", ")", "self", ".", "QUEUE", ".", "task_done", "(", ")", "except", "asyncio", ".", "QueueEmpty", ":", "if", "self", ".", "OPEN", ":", "await", "self", ".", "sleep", "(", "0.05", ")", "else", ":", "Log", ".", "debug", "(", "'%s queue closed and empty, stopping'", ",", "self", ".", "name", ")", "return", "except", "CancelledError", ":", "Log", ".", "debug", "(", "'%s cancelled, dropping work item'", ")", "self", ".", "QUEUE", ".", "task_done", "(", ")", "raise", "except", "Exception", ":", "Log", ".", "exception", "(", "'%s failed work item'", ",", "self", ".", "name", ")", "self", ".", "QUEUE", ".", "task_done", "(", ")" ]

[ "Initialize", "the", "queue", "and", "spawn", "extra", "worker", "tasks", "if", "this", "if", "the", "first", "task", ".", "Then", "wait", "for", "work", "items", "to", "enter", "the", "task", "queue", "and", "execute", "the", "run", "()", "method", "with", "the", "current", "work", "item", "." ]

[ "def", "schedule_saved", "(", "sender", ",", "instance", ",", "*", "*", "kwargs", ")", ":", "from", "contentstore", ".", "tasks", "import", "sync_schedule", "sync_schedule", ".", "delay", "(", "str", "(", "instance", ".", "id", ")", ")" ]

[ "Fires", "off", "the", "celery", "task", "to", "ensure", "that", "this", "schedule", "is", "in", "the", "scheduler" ]

[ "def", "schedule_deleted", "(", "sender", ",", "instance", ",", "*", "*", "kwargs", ")", ":", "from", "contentstore", ".", "tasks", "import", "deactivate_schedule", "deactivate_schedule", ".", "delay", "(", "str", "(", "instance", ".", "scheduler_schedule_id", ")", ")" ]

[ "Fires", "off", "the", "celery", "task", "to", "ensure", "that", "this", "schedule", "is", "deactivated" ]

[ "async", "def", "run_task", "(", "self", ")", "->", "None", ":", "while", "self", ".", "running", ":", "try", ":", "Log", ".", "debug", "(", "'executing periodic task %s'", ",", "self", ".", "name", ")", "before", "=", "self", ".", "time", "(", ")", "await", "self", ".", "run", "(", ")", "total", "=", "self", ".", "time", "(", ")", "-", "before", "Log", ".", "debug", "(", "'finished periodic task %s in %.1f seconds'", ",", "self", ".", "name", ",", "total", ")", "sleep", "=", "self", ".", "INTERVAL", "-", "total", "if", "sleep", ">", "0", ":", "await", "self", ".", "sleep", "(", "sleep", ")", "except", "CancelledError", ":", "Log", ".", "debug", "(", "'cancelled periodic task %s'", ",", "self", ".", "name", ")", "raise", "except", "Exception", ":", "Log", ".", "exception", "(", "'exception in periodic task %s'", ",", "self", ".", "name", ")" ]

[ "Execute", "the", "task", "inside", "the", "asyncio", "event", "loop", ".", "Track", "the", "time", "it", "takes", "to", "run", "and", "log", "when", "it", "starts", "/", "stops", ".", "After", "INTERVAL", "seconds", "if", "/", "once", "the", "task", "has", "finished", "running", "run", "it", "again", "until", "stop", "()", "is", "called", "." ]

[ "def", "group_by", "(", "keys", ",", "values", "=", "None", ",", "reduction", "=", "None", ",", "axis", "=", "0", ")", ":", "g", "=", "GroupBy", "(", "keys", ",", "axis", ")", "if", "values", "is", "None", ":", "return", "g", "groups", "=", "g", ".", "split", "(", "values", ")", "if", "reduction", "is", "None", ":", "return", "g", ".", "unique", ",", "groups", "return", "[", "(", "key", ",", "reduction", "(", "group", ")", ")", "for", "key", ",", "group", "in", "zip", "(", "g", ".", "unique", ",", "groups", ")", "]" ]

[ "construct", "a", "grouping", "object", "on", "the", "given", "keys", "optionally", "performing", "the", "given", "reduction", "on", "the", "given", "values" ]

[ "def", "split_iterable_as_iterable", "(", "self", ",", "values", ")", ":", "values", "=", "iter", "(", "enumerate", "(", "values", ")", ")", "cache", "=", "dict", "(", ")", "def", "get_value", "(", "ti", ")", ":", "try", ":", "return", "cache", ".", "pop", "(", "ti", ")", "except", ":", "while", "True", ":", "i", ",", "v", "=", "next", "(", "values", ")", "if", "i", "==", "ti", ":", "return", "v", "cache", "[", "i", "]", "=", "v", "s", "=", "iter", "(", "self", ".", "index", ".", "sorter", ")", "for", "c", "in", "self", ".", "count", ":", "yield", "(", "get_value", "(", "i", ")", "for", "i", "in", "itertools", ".", "islice", "(", "s", ",", "int", "(", "c", ")", ")", ")" ]

[ "Group", "iterable", "into", "iterables", "in", "the", "order", "of", "the", "keys" ]

[ "def", "split_iterable_as_unordered_iterable", "(", "self", ",", "values", ")", ":", "from", "collections", "import", "defaultdict", "cache", "=", "defaultdict", "(", "list", ")", "count", "=", "self", ".", "count", "unique", "=", "self", ".", "unique", "key", "=", "(", "lambda", "i", ":", "unique", "[", "i", "]", ")", "if", "isinstance", "(", "unique", ",", "np", ".", "ndarray", ")", "else", "(", "lambda", "i", ":", "tuple", "(", "c", "[", "i", "]", "for", "c", "in", "unique", ")", ")", "for", "i", ",", "v", "in", "zip", "(", "self", ".", "inverse", ",", "values", ")", ":", "cache", "[", "i", "]", ".", "append", "(", "v", ")", "if", "len", "(", "cache", "[", "i", "]", ")", "==", "count", "[", "i", "]", ":", "yield", "key", "(", "i", ")", ",", "cache", ".", "pop", "(", "i", ")" ]

[ "Group", "iterable", "into", "iterables", "without", "regard", "for", "the", "ordering", "of", "self", ".", "index", ".", "unique", "key", "-", "group", "tuples", "are", "yielded", "as", "soon", "as", "they", "are", "complete" ]

[ "def", "split_sequence_as_iterable", "(", "self", ",", "values", ")", ":", "print", "(", "self", ".", "count", ")", "s", "=", "iter", "(", "self", ".", "index", ".", "sorter", ")", "for", "c", "in", "self", ".", "count", ":", "yield", "(", "values", "[", "i", "]", "for", "i", "in", "itertools", ".", "islice", "(", "s", ",", "int", "(", "c", ")", ")", ")" ]

[ "Group", "sequence", "into", "iterables" ]

[ "def", "split_array_as_array", "(", "self", ",", "values", ")", ":", "if", "not", "self", ".", "index", ".", "uniform", ":", "raise", "ValueError", "(", "\"Array can only be split as array if all groups have the same size\"", ")", "values", "=", "np", ".", "asarray", "(", "values", ")", "values", "=", "values", "[", "self", ".", "index", ".", "sorter", "]", "return", "values", ".", "reshape", "(", "self", ".", "groups", ",", "-", "1", ",", "*", "values", ".", "shape", "[", "1", ":", "]", ")" ]

[ "Group", "ndarray", "into", "ndarray", "by", "means", "of", "reshaping" ]

[ "def", "split_array_as_list", "(", "self", ",", "values", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "values", "=", "values", "[", "self", ".", "index", ".", "sorter", "]", "return", "np", ".", "split", "(", "values", ",", "self", ".", "index", ".", "slices", "[", "1", ":", "-", "1", "]", ",", "axis", "=", "0", ")" ]

[ "Group", "values", "as", "a", "list", "of", "arrays", "or", "a", "jagged", "-", "array" ]

[ "def", "reduce", "(", "self", ",", "values", ",", "operator", "=", "np", ".", "add", ",", "axis", "=", "0", ",", "dtype", "=", "None", ")", ":", "values", "=", "np", ".", "take", "(", "values", ",", "self", ".", "index", ".", "sorter", ",", "axis", "=", "axis", ")", "return", "operator", ".", "reduceat", "(", "values", ",", "self", ".", "index", ".", "start", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")" ]

[ "Reduce", "the", "values", "over", "identical", "key", "groups", "using", "the", "given", "ufunc", "reduction", "is", "over", "the", "first", "axis", "which", "should", "have", "elements", "corresponding", "to", "the", "keys", "all", "other", "axes", "are", "treated", "indepenently", "for", "the", "sake", "of", "this", "reduction" ]

[ "def", "sum", "(", "self", ",", "values", ",", "axis", "=", "0", ",", "dtype", "=", "None", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "self", ".", "reduce", "(", "values", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")" ]

[ "compute", "the", "sum", "over", "each", "group" ]

[ "def", "prod", "(", "self", ",", "values", ",", "axis", "=", "0", ",", "dtype", "=", "None", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "self", ".", "reduce", "(", "values", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ",", "operator", "=", "np", ".", "multiply", ")" ]

[ "compute", "the", "product", "over", "each", "group" ]

[ "def", "mean", "(", "self", ",", "values", ",", "axis", "=", "0", ",", "weights", "=", "None", ",", "dtype", "=", "None", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "if", "weights", "is", "None", ":", "result", "=", "self", ".", "reduce", "(", "values", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")", "shape", "=", "[", "1", "]", "*", "values", ".", "ndim", "shape", "[", "axis", "]", "=", "self", ".", "groups", "weights", "=", "self", ".", "count", ".", "reshape", "(", "shape", ")", "else", ":", "weights", "=", "np", ".", "asarray", "(", "weights", ")", "result", "=", "self", ".", "reduce", "(", "values", "*", "weights", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")", "weights", "=", "self", ".", "reduce", "(", "weights", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")", "return", "self", ".", "unique", ",", "result", "/", "weights" ]

[ "compute", "the", "mean", "over", "each", "group" ]

[ "def", "var", "(", "self", ",", "values", ",", "axis", "=", "0", ",", "weights", "=", "None", ",", "dtype", "=", "None", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "unique", ",", "mean", "=", "self", ".", "mean", "(", "values", ",", "axis", ",", "weights", ",", "dtype", ")", "err", "=", "values", "-", "mean", ".", "take", "(", "self", ".", "inverse", ",", "axis", ")", "if", "weights", "is", "None", ":", "shape", "=", "[", "1", "]", "*", "values", ".", "ndim", "shape", "[", "axis", "]", "=", "self", ".", "groups", "group_weights", "=", "self", ".", "count", ".", "reshape", "(", "shape", ")", "var", "=", "self", ".", "reduce", "(", "err", "**", "2", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")", "else", ":", "weights", "=", "np", ".", "asarray", "(", "weights", ")", "group_weights", "=", "self", ".", "reduce", "(", "weights", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")", "var", "=", "self", ".", "reduce", "(", "weights", "*", "err", "**", "2", ",", "axis", "=", "axis", ",", "dtype", "=", "dtype", ")", "return", "unique", ",", "var", "/", "group_weights" ]

[ "compute", "the", "variance", "over", "each", "group" ]

[ "def", "std", "(", "self", ",", "values", ",", "axis", "=", "0", ",", "weights", "=", "None", ",", "dtype", "=", "None", ")", ":", "unique", ",", "var", "=", "self", ".", "var", "(", "values", ",", "axis", ",", "weights", ",", "dtype", ")", "return", "unique", ",", "np", ".", "sqrt", "(", "var", ")" ]

[ "standard", "deviation", "over", "each", "group" ]

[ "def", "median", "(", "self", ",", "values", ",", "axis", "=", "0", ",", "average", "=", "True", ")", ":", "mid_2", "=", "self", ".", "index", ".", "start", "+", "self", ".", "index", ".", "stop", "hi", "=", "(", "mid_2", ")", "//", "2", "lo", "=", "(", "mid_2", "-", "1", ")", "//", "2", "#need this indirection for lex-index compatibility", "sorted_group_rank_per_key", "=", "self", ".", "index", ".", "sorted_group_rank_per_key", "def", "median1d", "(", "slc", ")", ":", "#place values at correct keys; preconditions the upcoming lexsort", "slc", "=", "slc", "[", "self", ".", "index", ".", "sorter", "]", "#refine value sorting within each keygroup", "sorter", "=", "np", ".", "lexsort", "(", "(", "slc", ",", "sorted_group_rank_per_key", ")", ")", "slc", "=", "slc", "[", "sorter", "]", "return", "(", "slc", "[", "lo", "]", "+", "slc", "[", "hi", "]", ")", "/", "2", "if", "average", "else", "slc", "[", "hi", "]", "values", "=", "np", ".", "asarray", "(", "values", ")", "if", "values", ".", "ndim", ">", "1", ":", "#is trying to skip apply_along_axis somewhat premature optimization?", "values", "=", "np", ".", "apply_along_axis", "(", "median1d", ",", "axis", ",", "values", ")", "else", ":", "values", "=", "median1d", "(", "values", ")", "return", "self", ".", "unique", ",", "values" ]

[ "compute", "the", "median", "value", "over", "each", "group", "." ]

[ "def", "mode", "(", "self", ",", "values", ",", "weights", "=", "None", ")", ":", "if", "weights", "is", "None", ":", "unique", ",", "weights", "=", "npi", ".", "count", "(", "(", "self", ".", "index", ".", "sorted_group_rank_per_key", ",", "values", ")", ")", "else", ":", "unique", ",", "weights", "=", "npi", ".", "group_by", "(", "(", "self", ".", "index", ".", "sorted_group_rank_per_key", ",", "values", ")", ")", ".", "sum", "(", "weights", ")", "x", ",", "bin", "=", "npi", ".", "group_by", "(", "unique", "[", "0", "]", ")", ".", "argmax", "(", "weights", ")", "return", "x", ",", "unique", "[", "1", "]", "[", "bin", "]" ]

[ "compute", "the", "mode", "within", "each", "group", "." ]

[ "def", "min", "(", "self", ",", "values", ",", "axis", "=", "0", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "self", ".", "reduce", "(", "values", ",", "np", ".", "minimum", ",", "axis", ")" ]

[ "return", "the", "minimum", "within", "each", "group" ]

[ "def", "max", "(", "self", ",", "values", ",", "axis", "=", "0", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "self", ".", "reduce", "(", "values", ",", "np", ".", "maximum", ",", "axis", ")" ]

[ "return", "the", "maximum", "within", "each", "group" ]

[ "def", "first", "(", "self", ",", "values", ",", "axis", "=", "0", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "np", ".", "take", "(", "values", ",", "self", ".", "index", ".", "sorter", "[", "self", ".", "index", ".", "start", "]", ",", "axis", ")" ]

[ "return", "values", "at", "first", "occurance", "of", "its", "associated", "key" ]

[ "def", "last", "(", "self", ",", "values", ",", "axis", "=", "0", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "np", ".", "take", "(", "values", ",", "self", ".", "index", ".", "sorter", "[", "self", ".", "index", ".", "stop", "-", "1", "]", ",", "axis", ")" ]

[ "return", "values", "at", "last", "occurance", "of", "its", "associated", "key" ]

[ "def", "any", "(", "self", ",", "values", ",", "axis", "=", "0", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "if", "not", "values", ".", "dtype", "==", "np", ".", "bool", ":", "values", "=", "values", "!=", "0", "return", "self", ".", "unique", ",", "self", ".", "reduce", "(", "values", ",", "axis", "=", "axis", ")", ">", "0" ]

[ "compute", "if", "any", "item", "evaluates", "to", "true", "in", "each", "group" ]

[ "def", "all", "(", "self", ",", "values", ",", "axis", "=", "0", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "return", "self", ".", "unique", ",", "self", ".", "reduce", "(", "values", ",", "axis", "=", "axis", ",", "operator", "=", "np", ".", "multiply", ")", "!=", "0" ]

[ "compute", "if", "all", "items", "evaluates", "to", "true", "in", "each", "group" ]

[ "def", "argmin", "(", "self", ",", "values", ")", ":", "keys", ",", "minima", "=", "self", ".", "min", "(", "values", ")", "minima", "=", "minima", "[", "self", ".", "inverse", "]", "# select the first occurence of the minimum in each group", "index", "=", "as_index", "(", "(", "self", ".", "inverse", ",", "values", "==", "minima", ")", ")", "return", "keys", ",", "index", ".", "sorter", "[", "index", ".", "start", "[", "-", "self", ".", "groups", ":", "]", "]" ]

[ "return", "the", "index", "into", "values", "corresponding", "to", "the", "minimum", "value", "of", "the", "group" ]

[ "def", "argmax", "(", "self", ",", "values", ")", ":", "keys", ",", "maxima", "=", "self", ".", "max", "(", "values", ")", "maxima", "=", "maxima", "[", "self", ".", "inverse", "]", "# select the first occurence of the maximum in each group", "index", "=", "as_index", "(", "(", "self", ".", "inverse", ",", "values", "==", "maxima", ")", ")", "return", "keys", ",", "index", ".", "sorter", "[", "index", ".", "start", "[", "-", "self", ".", "groups", ":", "]", "]" ]

[ "return", "the", "index", "into", "values", "corresponding", "to", "the", "maximum", "value", "of", "the", "group" ]

[ "def", "as_index", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ",", "base", "=", "False", ",", "stable", "=", "True", ",", "lex_as_struct", "=", "False", ")", ":", "if", "isinstance", "(", "keys", ",", "Index", ")", ":", "if", "type", "(", "keys", ")", "is", "BaseIndex", "and", "base", "==", "False", ":", "keys", "=", "keys", ".", "keys", "#need to upcast to an indirectly sorted index type", "else", ":", "return", "keys", "#already done here", "if", "isinstance", "(", "keys", ",", "tuple", ")", ":", "if", "lex_as_struct", ":", "keys", "=", "as_struct_array", "(", "*", "keys", ")", "else", ":", "return", "LexIndex", "(", "keys", ",", "stable", ")", "try", ":", "keys", "=", "np", ".", "asarray", "(", "keys", ")", "except", ":", "raise", "TypeError", "(", "'Given object does not form a valid set of keys'", ")", "if", "axis", "is", "None", ":", "keys", "=", "keys", ".", "flatten", "(", ")", "if", "keys", ".", "ndim", "==", "1", ":", "if", "base", ":", "return", "BaseIndex", "(", "keys", ")", "else", ":", "return", "Index", "(", "keys", ",", "stable", "=", "stable", ")", "else", ":", "return", "ObjectIndex", "(", "keys", ",", "axis", ",", "stable", "=", "stable", ")" ]

[ "casting", "rules", "for", "a", "keys", "object", "to", "an", "index", "object" ]

[ "def", "inverse", "(", "self", ")", ":", "inv", "=", "np", ".", "empty", "(", "self", ".", "size", ",", "np", ".", "int", ")", "inv", "[", "self", ".", "sorter", "]", "=", "self", ".", "sorted_group_rank_per_key", "return", "inv" ]

[ "return", "index", "array", "that", "maps", "unique", "values", "back", "to", "original", "space", ".", "unique", "[", "inverse", "]", "==", "keys" ]

[ "def", "rank", "(", "self", ")", ":", "r", "=", "np", ".", "empty", "(", "self", ".", "size", ",", "np", ".", "int", ")", "r", "[", "self", ".", "sorter", "]", "=", "np", ".", "arange", "(", "self", ".", "size", ")", "return", "r" ]

[ "how", "high", "in", "sorted", "list", "each", "key", "is", ".", "inverse", "permutation", "of", "sorter", "such", "that", "sorted", "[", "rank", "]", "==", "keys" ]

[ "def", "unique", "(", "self", ")", ":", "return", "tuple", "(", "(", "array_as_typed", "(", "s", ",", "k", ".", "dtype", ",", "k", ".", "shape", ")", "if", "k", ".", "ndim", ">", "1", "else", "s", ")", "[", "self", ".", "start", "]", "for", "s", ",", "k", "in", "zip", "(", "self", ".", "sorted", ",", "self", ".", "_keys", ")", ")" ]

[ "returns", "a", "tuple", "of", "unique", "key", "columns" ]

[ "def", "as_struct_array", "(", "*", "columns", ")", ":", "columns", "=", "[", "np", ".", "asarray", "(", "c", ")", "for", "c", "in", "columns", "]", "rows", "=", "len", "(", "columns", "[", "0", "]", ")", "names", "=", "[", "'f'", "+", "str", "(", "i", ")", "for", "i", "in", "range", "(", "len", "(", "columns", ")", ")", "]", "dtype", "=", "[", "(", "names", "[", "i", "]", ",", "c", ".", "dtype", ",", "c", ".", "shape", "[", "1", ":", "]", ")", "for", "i", ",", "c", "in", "enumerate", "(", "columns", ")", "]", "data", "=", "np", ".", "empty", "(", "rows", ",", "dtype", ")", "for", "i", ",", "c", "in", "enumerate", "(", "columns", ")", ":", "data", "[", "names", "[", "i", "]", "]", "=", "c", "return", "data" ]

[ "pack", "a", "sequence", "of", "columns", "into", "a", "recarray" ]

[ "def", "axis_as_object", "(", "arr", ",", "axis", "=", "-", "1", ")", ":", "shape", "=", "arr", ".", "shape", "# make axis to be viewed as a void object as contiguous items", "arr", "=", "np", ".", "ascontiguousarray", "(", "np", ".", "rollaxis", "(", "arr", ",", "axis", ",", "arr", ".", "ndim", ")", ")", "# number of bytes in each void object", "nbytes", "=", "arr", ".", "dtype", ".", "itemsize", "*", "shape", "[", "axis", "]", "# void type with the correct number of bytes", "voidtype", "=", "np", ".", "dtype", "(", "(", "np", ".", "void", ",", "nbytes", ")", ")", "# return the view as such, with the reduced shape", "return", "arr", ".", "view", "(", "voidtype", ")", ".", "reshape", "(", "np", ".", "delete", "(", "shape", ",", "axis", ")", ")" ]

[ "cast", "the", "given", "axis", "of", "an", "array", "to", "a", "void", "object", "if", "the", "axis", "to", "be", "cast", "is", "contiguous", "a", "view", "is", "returned", "otherwise", "a", "copy", "is", "made", "this", "is", "useful", "for", "efficiently", "sorting", "by", "the", "content", "of", "an", "axis", "for", "instance" ]

[ "def", "object_as_axis", "(", "arr", ",", "dtype", ",", "axis", "=", "-", "1", ")", ":", "# view the void objects as typed elements", "arr", "=", "arr", ".", "view", "(", "dtype", ")", ".", "reshape", "(", "arr", ".", "shape", "+", "(", "-", "1", ",", ")", ")", "# put the axis in the specified location", "return", "np", ".", "rollaxis", "(", "arr", ",", "-", "1", ",", "axis", ")" ]

[ "cast", "an", "array", "of", "void", "objects", "to", "a", "typed", "axis" ]

[ "def", "count", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ",", "base", "=", "True", ")", "return", "index", ".", "unique", ",", "index", ".", "count" ]

[ "count", "the", "number", "of", "times", "each", "key", "occurs", "in", "the", "input", "set" ]

[ "def", "count_table", "(", "*", "keys", ")", ":", "indices", "=", "[", "as_index", "(", "k", ",", "axis", "=", "0", ")", "for", "k", "in", "keys", "]", "uniques", "=", "[", "i", ".", "unique", "for", "i", "in", "indices", "]", "inverses", "=", "[", "i", ".", "inverse", "for", "i", "in", "indices", "]", "shape", "=", "[", "i", ".", "groups", "for", "i", "in", "indices", "]", "table", "=", "np", ".", "zeros", "(", "shape", ",", "np", ".", "int", ")", "np", ".", "add", ".", "at", "(", "table", ",", "inverses", ",", "1", ")", "return", "tuple", "(", "uniques", ")", ",", "table" ]

[ "count", "the", "number", "of", "times", "each", "key", "occurs", "in", "the", "input", "set" ]

[ "def", "binning", "(", "keys", ",", "start", ",", "end", ",", "count", ",", "axes", "=", "None", ")", ":", "if", "isinstance", "(", "keys", ",", "tuple", ")", ":", "n_keys", "=", "len", "(", "keys", ")", "else", ":", "n_keys", "=", "1", "bins", "=", "np", ".", "linspace", "(", "start", ",", "end", ",", "count", "+", "1", ",", "endpoint", "=", "True", ")", "idx", "=", "np", ".", "searchsorted", "(", "bins", ",", "keys", ")", "if", "axes", "is", "None", ":", "axes", "=", "[", "-", "1", "]" ]

[ "Perform", "binning", "over", "the", "given", "axes", "of", "the", "keys" ]

[ "def", "multiplicity", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "return", "index", ".", "count", "[", "index", ".", "inverse", "]" ]

[ "return", "the", "multiplicity", "of", "each", "key", "or", "how", "often", "it", "occurs", "in", "the", "set" ]

[ "def", "rank", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "return", "index", ".", "rank" ]

[ "where", "each", "item", "is", "in", "the", "pecking", "order", "." ]

[ "def", "mode", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ",", "weights", "=", "None", ",", "return_indices", "=", "False", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "if", "weights", "is", "None", ":", "unique", ",", "weights", "=", "count", "(", "index", ")", "else", ":", "unique", ",", "weights", "=", "group_by", "(", "index", ")", ".", "sum", "(", "weights", ")", "bin", "=", "np", ".", "argmax", "(", "weights", ")", "_mode", "=", "unique", "[", "bin", "]", "# FIXME: replace with index.take for lexindex compatibility?", "if", "return_indices", ":", "indices", "=", "index", ".", "sorter", "[", "index", ".", "start", "[", "bin", "]", ":", "index", ".", "stop", "[", "bin", "]", "]", "return", "_mode", ",", "indices", "else", ":", "return", "_mode" ]

[ "compute", "the", "mode", "or", "most", "frequent", "occuring", "key", "in", "a", "set" ]

[ "def", "incidence", "(", "boundary", ")", ":", "return", "GroupBy", "(", "boundary", ")", ".", "split", "(", "np", ".", "arange", "(", "boundary", ".", "size", ")", "//", "boundary", ".", "shape", "[", "1", "]", ")" ]

[ "given", "an", "Nxm", "matrix", "containing", "boundary", "info", "between", "simplices", "compute", "indidence", "info", "matrix", "not", "very", "reusable", ";", "should", "probably", "not", "be", "in", "this", "lib" ]

[ "def", "all_unique", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "return", "index", ".", "groups", "==", "index", ".", "size" ]

[ "Returns", "true", "if", "all", "keys", "are", "unique" ]

[ "def", "any_unique", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "return", "np", ".", "any", "(", "index", ".", "count", "==", "1", ")" ]

[ "returns", "true", "if", "any", "of", "the", "keys", "is", "unique" ]

[ "def", "all_equal", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "return", "index", ".", "groups", "==", "1" ]

[ "returns", "true", "of", "all", "keys", "are", "equal" ]

[ "def", "is_uniform", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "index", "=", "as_index", "(", "keys", ",", "axis", ")", "return", "index", ".", "uniform" ]

[ "returns", "true", "if", "all", "keys", "have", "equal", "multiplicity" ]

[ "def", "get_inverses", "(", "self", ",", "keys", ")", ":", "return", "tuple", "(", "[", "as_index", "(", "k", ",", "axis", "=", "0", ")", ".", "inverse", "for", "k", "in", "keys", "]", ")" ]

[ "Returns", "-------", "Tuple", "of", "inverse", "indices" ]

[ "def", "unique", "(", "self", ",", "values", ")", ":", "_", ",", "count", "=", "self", ".", "count", "(", ")", "if", "not", "np", ".", "array_equiv", "(", "count", ",", "1", ")", ":", "raise", "ValueError", "(", "\"Not every entry in the table is assigned a unique value\"", ")", "return", "self", ".", "sum", "(", "values", ")" ]

[ "Place", "each", "entry", "in", "a", "table", "while", "asserting", "that", "each", "entry", "occurs", "once" ]

[ "def", "unique", "(", "keys", ",", "axis", "=", "semantics", ".", "axis_default", ",", "return_index", "=", "False", ",", "return_inverse", "=", "False", ",", "return_count", "=", "False", ")", ":", "stable", "=", "return_index", "or", "return_inverse", "index", "=", "as_index", "(", "keys", ",", "axis", ",", "base", "=", "not", "stable", ",", "stable", "=", "stable", ")", "ret", "=", "index", ".", "unique", ",", "if", "return_index", ":", "ret", "=", "ret", "+", "(", "index", ".", "index", ",", ")", "if", "return_inverse", ":", "ret", "=", "ret", "+", "(", "index", ".", "inverse", ",", ")", "if", "return_count", ":", "ret", "=", "ret", "+", "(", "index", ".", "count", ",", ")", "return", "ret", "[", "0", "]", "if", "len", "(", "ret", ")", "==", "1", "else", "ret" ]

[ "compute", "the", "set", "of", "unique", "keys" ]

[ "def", "contains", "(", "this", ",", "that", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "this", "=", "as_index", "(", "this", ",", "axis", "=", "axis", ",", "lex_as_struct", "=", "True", ",", "base", "=", "True", ")", "that", "=", "as_index", "(", "that", ",", "axis", "=", "axis", ",", "lex_as_struct", "=", "True", ")", "left", "=", "np", ".", "searchsorted", "(", "that", ".", "_keys", ",", "this", ".", "_keys", ",", "sorter", "=", "that", ".", "sorter", ",", "side", "=", "'left'", ")", "right", "=", "np", ".", "searchsorted", "(", "that", ".", "_keys", ",", "this", ".", "_keys", ",", "sorter", "=", "that", ".", "sorter", ",", "side", "=", "'right'", ")", "flags", "=", "np", ".", "zeros", "(", "that", ".", "size", "+", "1", ",", "dtype", "=", "np", ".", "int", ")", "np", ".", "add", ".", "at", "(", "flags", ",", "left", ",", "1", ")", "np", ".", "add", ".", "at", "(", "flags", ",", "right", ",", "-", "1", ")", "return", "np", ".", "cumsum", "(", "flags", ")", "[", ":", "-", "1", "]", ".", "astype", "(", "np", ".", "bool", ")", "[", "that", ".", "rank", "]" ]

[ "Returns", "bool", "for", "each", "element", "of", "that", "indicating", "if", "it", "is", "contained", "in", "this" ]

[ "def", "in_", "(", "this", ",", "that", ",", "axis", "=", "semantics", ".", "axis_default", ")", ":", "this", "=", "as_index", "(", "this", ",", "axis", "=", "axis", ",", "lex_as_struct", "=", "True", ",", "base", "=", "True", ")", "that", "=", "as_index", "(", "that", ",", "axis", "=", "axis", ",", "lex_as_struct", "=", "True", ")", "left", "=", "np", ".", "searchsorted", "(", "that", ".", "_keys", ",", "this", ".", "_keys", ",", "sorter", "=", "that", ".", "sorter", ",", "side", "=", "'left'", ")", "right", "=", "np", ".", "searchsorted", "(", "that", ".", "_keys", ",", "this", ".", "_keys", ",", "sorter", "=", "that", ".", "sorter", ",", "side", "=", "'right'", ")", "return", "left", "!=", "right" ]

[ "Returns", "bool", "for", "each", "element", "of", "this", "indicating", "if", "it", "is", "present", "in", "that" ]

[ "def", "indices", "(", "this", ",", "that", ",", "axis", "=", "semantics", ".", "axis_default", ",", "missing", "=", "'raise'", ")", ":", "this", "=", "as_index", "(", "this", ",", "axis", "=", "axis", ",", "lex_as_struct", "=", "True", ")", "# use this for getting this.keys and that.keys organized the same way;", "# sorting is superfluous though. make sorting a cached property?", "# should we be working with cached properties generally?", "# or we should use sorted values, if searchsorted can exploit this knowledge?", "that", "=", "as_index", "(", "that", ",", "axis", "=", "axis", ",", "base", "=", "True", ",", "lex_as_struct", "=", "True", ")", "# use raw private keys here, rather than public unpacked keys", "insertion", "=", "np", ".", "searchsorted", "(", "this", ".", "_keys", ",", "that", ".", "_keys", ",", "sorter", "=", "this", ".", "sorter", ",", "side", "=", "'left'", ")", "indices", "=", "np", ".", "take", "(", "this", ".", "sorter", ",", "insertion", ",", "mode", "=", "'clip'", ")", "if", "missing", "!=", "'ignore'", ":", "invalid", "=", "this", ".", "_keys", "[", "indices", "]", "!=", "that", ".", "_keys", "if", "missing", "==", "'raise'", ":", "if", "np", ".", "any", "(", "invalid", ")", ":", "raise", "KeyError", "(", "'Not all keys in `that` are present in `this`'", ")", "elif", "missing", "==", "'mask'", ":", "indices", "=", "np", ".", "ma", ".", "masked_array", "(", "indices", ",", "invalid", ")", "else", ":", "indices", "[", "invalid", "]", "=", "missing", "return", "indices" ]

[ "Find", "indices", "such", "that", "this", "[", "indices", "]", "==", "that", "If", "multiple", "indices", "satisfy", "this", "condition", "the", "first", "index", "found", "is", "returned" ]

[ "def", "remap", "(", "input", ",", "keys", ",", "values", ",", "missing", "=", "'ignore'", ",", "inplace", "=", "False", ")", ":", "input", "=", "np", ".", "asarray", "(", "input", ")", "# FIXME: currently instances of Index are not allowed", "values", "=", "np", ".", "asarray", "(", "values", ")", "if", "missing", "==", "'ignore'", ":", "idx", "=", "indices", "(", "keys", ",", "input", ",", "missing", "=", "'mask'", ")", "mask", "=", "np", ".", "logical_not", "(", "idx", ".", "mask", ")", "idx", "=", "idx", ".", "data", "elif", "missing", "==", "'raise'", ":", "idx", "=", "indices", "(", "keys", ",", "input", ",", "missing", "=", "'raise'", ")", "mask", "=", "Ellipsis", "else", ":", "raise", "ValueError", "(", "\"'missing' should be either 'ignore' or 'raise'\"", ")", "output", "=", "input", "if", "inplace", "else", "input", ".", "copy", "(", ")", "output", "[", "mask", "]", "=", "values", "[", "idx", "[", "mask", "]", "]", "return", "output" ]

[ "Given", "an", "input", "array", "remap", "its", "entries", "corresponding", "to", "keys", "to", "values", "equivalent", "of", "output", "=", "[", "map", ".", "get", "(", "i", "default", "=", "i", ")", "for", "i", "in", "input", "]", "if", "map", "were", "a", "dictionary", "of", "corresponding", "keys", "and", "values" ]

[ "def", "_set_preprocess", "(", "sets", ",", "*", "*", "kwargs", ")", ":", "axis", "=", "kwargs", ".", "get", "(", "'axis'", ",", "semantics", ".", "axis_default", ")", "assume_unique", "=", "kwargs", ".", "get", "(", "'assume_unique'", ",", "False", ")", "if", "assume_unique", ":", "sets", "=", "[", "as_index", "(", "s", ",", "axis", "=", "axis", ")", ".", "unique", "for", "s", "in", "sets", "]", "else", ":", "sets", "=", "[", "as_index", "(", "s", ",", "axis", "=", "axis", ")", ".", "unique", "for", "s", "in", "sets", "]", "return", "sets" ]

[ "upcasts", "a", "sequence", "of", "indexable", "objects", "to", "Index", "objets", "according", "to", "the", "given", "kwargs" ]

[ "def", "_set_concatenate", "(", "sets", ")", ":", "def", "con", "(", "set", ")", ":", "# if not all():", "# raise ValueError('concatenated keys must have the same dtype')", "try", ":", "return", "np", ".", "concatenate", "(", "[", "s", "for", "s", "in", "sets", "if", "len", "(", "s", ")", "]", ")", "except", "ValueError", ":", "return", "set", "[", "0", "]", "if", "any", "(", "not", "isinstance", "(", "s", ",", "tuple", ")", "for", "s", "in", "sets", ")", ":", "#assume all arrays", "return", "con", "(", "sets", ")", "else", ":", "#assume all tuples", "return", "tuple", "(", "con", "(", "s", ")", "for", "s", "in", "zip", "(", "*", "sets", ")", ")" ]

[ "concatenate", "indexable", "objects", "." ]

[ "def", "_set_count", "(", "sets", ",", "n", ",", "*", "*", "kwargs", ")", ":", "sets", "=", "_set_preprocess", "(", "sets", ",", "*", "*", "kwargs", ")", "i", "=", "as_index", "(", "_set_concatenate", "(", "sets", ")", ",", "axis", "=", "0", ",", "base", "=", "True", ")", "# FIXME : this does not work for lex-keys", "return", "i", ".", "unique", "[", "i", ".", "count", "==", "n", "]" ]

[ "return", "the", "elements", "which", "occur", "n", "times", "over", "the", "sequence", "of", "sets" ]

[ "def", "union", "(", "*", "sets", ",", "*", "*", "kwargs", ")", ":", "sets", "=", "_set_preprocess", "(", "sets", ",", "*", "*", "kwargs", ")", "return", "as_index", "(", "_set_concatenate", "(", "sets", ")", ",", "axis", "=", "0", ",", "base", "=", "True", ")", ".", "unique" ]

[ "all", "unique", "items", "which", "occur", "in", "any", "one", "of", "the", "sets" ]

[ "def", "difference", "(", "*", "sets", ",", "*", "*", "kwargs", ")", ":", "head", ",", "tail", "=", "sets", "[", "0", "]", ",", "sets", "[", "1", ":", "]", "idx", "=", "as_index", "(", "head", ",", "*", "*", "kwargs", ")", "lhs", "=", "idx", ".", "unique", "rhs", "=", "[", "intersection", "(", "idx", ",", "s", ",", "*", "*", "kwargs", ")", "for", "s", "in", "tail", "]", "return", "exclusive", "(", "lhs", ",", "*", "rhs", ",", "axis", "=", "0", ",", "assume_unique", "=", "True", ")" ]

[ "subtracts", "all", "tail", "sets", "from", "the", "head", "set" ]

[ "def", "_generate_div_id_chart", "(", "prefix", "=", "\"chart_id\"", ",", "digits", "=", "8", ")", ":", "choices", "=", "(", "random", ".", "randrange", "(", "0", ",", "52", ")", "for", "_", "in", "range", "(", "digits", ")", ")", "return", "prefix", "+", "\"\"", ".", "join", "(", "(", "string", ".", "ascii_letters", "[", "x", "]", "for", "x", "in", "choices", ")", ")" ]

[ "Generate", "a", "random", "id", "for", "div", "chart", "." ]

[ "def", "display_charts", "(", "df", ",", "chart_type", "=", "\"default\"", ",", "render_to", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "chart_type", "not", "in", "(", "\"default\"", ",", "\"stock\"", ")", ":", "raise", "ValueError", "(", "\"Wrong chart_type: accept 'default' or 'stock'.\"", ")", "chart_id", "=", "render_to", "if", "render_to", "is", "not", "None", "else", "_generate_div_id_chart", "(", ")", "json_data", "=", "serialize", "(", "df", ",", "render_to", "=", "chart_id", ",", "chart_type", "=", "chart_type", ",", "*", "*", "kwargs", ")", "content", "=", "\"\"\"<div id=\"{chart_id}\"</div>\n <script type=\"text/javascript\">{data}</script>\"\"\"", "return", "display", "(", "HTML", "(", "content", ".", "format", "(", "chart_id", "=", "chart_id", ",", "data", "=", "json_data", ")", ")", ")" ]

[ "Display", "you", "DataFrame", "with", "Highcharts", "." ]

[ "def", "_series_data_filter", "(", "data", ")", ":", "data", "=", "copy", ".", "deepcopy", "(", "data", ")", "if", "\"series\"", "in", "data", ":", "for", "series", "in", "data", "[", "\"series\"", "]", ":", "series", "[", "\"data\"", "]", "=", "\"[...]\"", "return", "data" ]

[ "Replace", "each", "data", "key", "in", "the", "list", "stored", "under", "series", "by", "[", "...", "]", "." ]

[ "def", "pretty_params", "(", "data", ",", "indent", "=", "2", ")", ":", "data_to_print", "=", "_series_data_filter", "(", "data", ")", "print", "(", "json", ".", "dumps", "(", "data_to_print", ",", "indent", "=", "indent", ")", ")" ]

[ "Pretty", "print", "your", "Highcharts", "params", "(", "into", "a", "JSON", ")", "." ]

[ "def", "get_additional_params", "(", "self", ",", "*", "*", "params", ")", ":", "# TODO: Move these params to their own vertical if needed.", "polling_params", "=", "[", "'locationschema'", ",", "'carrierschema'", ",", "'sorttype'", ",", "'sortorder'", ",", "'originairports'", ",", "'destinationairports'", ",", "'stops'", ",", "'outbounddeparttime'", ",", "'outbounddepartstarttime'", ",", "'outbounddepartendtime'", ",", "'inbounddeparttime'", ",", "'inbounddepartstarttime'", ",", "'inbounddepartendtime'", ",", "'duration'", ",", "'includecarriers'", ",", "'excludecarriers'", "]", "additional_params", "=", "dict", "(", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "params", ".", "items", "(", ")", "if", "key", "in", "polling_params", ")", "return", "additional_params" ]

[ "Filter", "to", "get", "the", "additional", "params", "needed", "for", "polling" ]

[ "def", "get_result", "(", "self", ",", "errors", "=", "GRACEFUL", ",", "*", "*", "params", ")", ":", "additional_params", "=", "self", ".", "get_additional_params", "(", "*", "*", "params", ")", "return", "self", ".", "poll_session", "(", "self", ".", "create_session", "(", "*", "*", "params", ")", ",", "errors", "=", "errors", ",", "*", "*", "additional_params", ")" ]

[ "Get", "all", "results", "no", "filtering", "etc", ".", "by", "creating", "and", "polling", "the", "session", "." ]

[ "def", "make_request", "(", "self", ",", "service_url", ",", "method", "=", "'get'", ",", "headers", "=", "None", ",", "data", "=", "None", ",", "callback", "=", "None", ",", "errors", "=", "GRACEFUL", ",", "*", "*", "params", ")", ":", "error_modes", "=", "(", "STRICT", ",", "GRACEFUL", ",", "IGNORE", ")", "error_mode", "=", "errors", "or", "GRACEFUL", "if", "error_mode", ".", "lower", "(", ")", "not", "in", "error_modes", ":", "raise", "ValueError", "(", "'Possible values for errors argument are: %s'", "%", "', '", ".", "join", "(", "error_modes", ")", ")", "if", "callback", "is", "None", ":", "callback", "=", "self", ".", "_default_resp_callback", "if", "'apikey'", "not", "in", "service_url", ".", "lower", "(", ")", ":", "params", ".", "update", "(", "{", "'apiKey'", ":", "self", ".", "api_key", "}", ")", "request", "=", "getattr", "(", "requests", ",", "method", ".", "lower", "(", ")", ")", "log", ".", "debug", "(", "'* Request URL: %s'", "%", "service_url", ")", "log", ".", "debug", "(", "'* Request method: %s'", "%", "method", ")", "log", ".", "debug", "(", "'* Request query params: %s'", "%", "params", ")", "log", ".", "debug", "(", "'* Request headers: %s'", "%", "headers", ")", "r", "=", "request", "(", "service_url", ",", "headers", "=", "headers", ",", "data", "=", "data", ",", "params", "=", "params", ")", "try", ":", "r", ".", "raise_for_status", "(", ")", "return", "callback", "(", "r", ")", "except", "Exception", "as", "e", ":", "return", "self", ".", "_with_error_handling", "(", "r", ",", "e", ",", "error_mode", ",", "self", ".", "response_format", ")" ]

[ "Reusable", "method", "for", "performing", "requests", "." ]

[ "def", "get_markets", "(", "self", ",", "market", ")", ":", "url", "=", "\"{url}/{market}\"", ".", "format", "(", "url", "=", "self", ".", "MARKET_SERVICE_URL", ",", "market", "=", "market", ")", "return", "self", ".", "make_request", "(", "url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ")" ]

[ "Get", "the", "list", "of", "markets", "http", ":", "//", "business", ".", "skyscanner", ".", "net", "/", "portal", "/", "en", "-", "GB", "/", "Documentation", "/", "Markets" ]

[ "def", "location_autosuggest", "(", "self", ",", "*", "*", "params", ")", ":", "service_url", "=", "\"{url}/{params_path}\"", ".", "format", "(", "url", "=", "self", ".", "LOCATION_AUTOSUGGEST_URL", ",", "params_path", "=", "self", ".", "_construct_params", "(", "params", ",", "self", ".", "LOCATION_AUTOSUGGEST_PARAMS", ")", ")", "return", "self", ".", "make_request", "(", "service_url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "*", "*", "params", ")" ]

[ "Location", "Autosuggest", "Services", "Doc", "URLs", ":" ]

[ "def", "poll_session", "(", "self", ",", "poll_url", ",", "initial_delay", "=", "2", ",", "delay", "=", "1", ",", "tries", "=", "20", ",", "errors", "=", "GRACEFUL", ",", "*", "*", "params", ")", ":", "time", ".", "sleep", "(", "initial_delay", ")", "poll_response", "=", "None", "for", "n", "in", "range", "(", "tries", ")", ":", "poll_response", "=", "self", ".", "make_request", "(", "poll_url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "errors", "=", "errors", ",", "*", "*", "params", ")", "if", "self", ".", "is_poll_complete", "(", "poll_response", ")", ":", "return", "poll_response", "else", ":", "time", ".", "sleep", "(", "delay", ")", "if", "STRICT", "==", "errors", ":", "raise", "ExceededRetries", "(", "\"Failed to poll within {0} tries.\"", ".", "format", "(", "tries", ")", ")", "else", ":", "return", "poll_response" ]

[ "Poll", "the", "URL", ":", "param", "poll_url", "-", "URL", "to", "poll", "should", "be", "returned", "by", "create_session", "call", ":", "param", "initial_delay", "-", "specifies", "how", "many", "seconds", "to", "wait", "before", "the", "first", "poll", ":", "param", "delay", "-", "specifies", "how", "many", "seconds", "to", "wait", "between", "the", "polls", ":", "param", "tries", "-", "number", "of", "polls", "to", "perform", ":", "param", "errors", "-", "errors", "handling", "mode", "see", "corresponding", "parameter", "in", "make_request", "method", ":", "param", "params", "-", "additional", "query", "params", "for", "each", "poll", "request" ]

[ "def", "_construct_params", "(", "params", ",", "required_keys", ",", "opt_keys", "=", "None", ")", ":", "try", ":", "params_list", "=", "[", "params", ".", "pop", "(", "key", ")", "for", "key", "in", "required_keys", "]", "except", "KeyError", "as", "e", ":", "raise", "MissingParameter", "(", "'Missing expected request parameter: %s'", "%", "e", ")", "if", "opt_keys", ":", "params_list", ".", "extend", "(", "[", "params", ".", "pop", "(", "key", ")", "for", "key", "in", "opt_keys", "if", "key", "in", "params", "]", ")", "return", "'/'", ".", "join", "(", "str", "(", "p", ")", "for", "p", "in", "params_list", ")" ]

[ "Construct", "params", "list", "in", "order", "of", "given", "keys", "." ]

[ "def", "create_session", "(", "self", ",", "*", "*", "params", ")", ":", "return", "self", ".", "make_request", "(", "self", ".", "PRICING_SESSION_URL", ",", "method", "=", "'post'", ",", "headers", "=", "self", ".", "_session_headers", "(", ")", ",", "callback", "=", "lambda", "resp", ":", "resp", ".", "headers", "[", "'location'", "]", ",", "data", "=", "params", ")" ]

[ "Create", "the", "session", "date", "format", ":", "YYYY", "-", "mm", "-", "dd", "location", ":", "ISO", "code" ]

[ "def", "request_booking_details", "(", "self", ",", "poll_url", ",", "*", "*", "params", ")", ":", "return", "self", ".", "make_request", "(", "\"%s/booking\"", "%", "poll_url", ",", "method", "=", "'put'", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "callback", "=", "lambda", "resp", ":", "resp", ".", "headers", "[", "'location'", "]", ",", "*", "*", "params", ")" ]

[ "Request", "for", "booking", "details", "URL", "Format", ":", "{", "API_HOST", "}", "/", "apiservices", "/", "pricing", "/", "v1", ".", "0", "/", "{", "session", "key", "}", "/", "booking", "?apiKey", "=", "{", "apiKey", "}" ]

[ "def", "get_cheapest_price_by_date", "(", "self", ",", "*", "*", "params", ")", ":", "service_url", "=", "\"{url}/{params_path}\"", ".", "format", "(", "url", "=", "self", ".", "BROWSE_DATES_SERVICE_URL", ",", "params_path", "=", "self", ".", "_construct_params", "(", "params", ",", "self", ".", "_REQ_PARAMS", ",", "self", ".", "_OPT_PARAMS", ")", ")", "return", "self", ".", "make_request", "(", "service_url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "*", "*", "params", ")" ]

[ "{", "API_HOST", "}", "/", "apiservices", "/", "browsedates", "/", "v1", ".", "0", "/", "{", "market", "}", "/", "{", "currency", "}", "/", "{", "locale", "}", "/", "{", "originPlace", "}", "/", "{", "destinationPlace", "}", "/", "{", "outboundPartialDate", "}", "/", "{", "inboundPartialDate", "}", "?apiKey", "=", "{", "apiKey", "}" ]

[ "def", "get_cheapest_price_by_route", "(", "self", ",", "*", "*", "params", ")", ":", "service_url", "=", "\"{url}/{params_path}\"", ".", "format", "(", "url", "=", "self", ".", "BROWSE_ROUTES_SERVICE_URL", ",", "params_path", "=", "self", ".", "_construct_params", "(", "params", ",", "self", ".", "_REQ_PARAMS", ",", "self", ".", "_OPT_PARAMS", ")", ")", "return", "self", ".", "make_request", "(", "service_url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "*", "*", "params", ")" ]

[ "{", "API_HOST", "}", "/", "apiservices", "/", "browseroutes", "/", "v1", ".", "0", "/", "{", "market", "}", "/", "{", "currency", "}", "/", "{", "locale", "}", "/", "{", "originPlace", "}", "/", "{", "destinationPlace", "}", "/", "{", "outboundPartialDate", "}", "/", "{", "inboundPartialDate", "}", "?apiKey", "=", "{", "apiKey", "}" ]

[ "def", "get_cheapest_quotes", "(", "self", ",", "*", "*", "params", ")", ":", "service_url", "=", "\"{url}/{params_path}\"", ".", "format", "(", "url", "=", "self", ".", "BROWSE_QUOTES_SERVICE_URL", ",", "params_path", "=", "self", ".", "_construct_params", "(", "params", ",", "self", ".", "_REQ_PARAMS", ",", "self", ".", "_OPT_PARAMS", ")", ")", "return", "self", ".", "make_request", "(", "service_url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "*", "*", "params", ")" ]

[ "{", "API_HOST", "}", "/", "apiservices", "/", "browsequotes", "/", "v1", ".", "0", "/", "{", "market", "}", "/", "{", "currency", "}", "/", "{", "locale", "}", "/", "{", "originPlace", "}", "/", "{", "destinationPlace", "}", "/", "{", "outboundPartialDate", "}", "/", "{", "inboundPartialDate", "}", "?apiKey", "=", "{", "apiKey", "}" ]

[ "def", "get_grid_prices_by_date", "(", "self", ",", "*", "*", "params", ")", ":", "service_url", "=", "\"{url}/{params_path}\"", ".", "format", "(", "url", "=", "self", ".", "BROWSE_GRID_SERVICE_URL", ",", "params_path", "=", "self", ".", "_construct_params", "(", "params", ",", "self", ".", "_REQ_PARAMS", ",", "self", ".", "_OPT_PARAMS", ")", ")", "return", "self", ".", "make_request", "(", "service_url", ",", "headers", "=", "self", ".", "_headers", "(", ")", ",", "*", "*", "params", ")" ]

[ "{", "API_HOST", "}", "/", "apiservices", "/", "browsegrid", "/", "v1", ".", "0", "/", "{", "market", "}", "/", "{", "currency", "}", "/", "{", "locale", "}", "/", "{", "originPlace", "}", "/", "{", "destinationPlace", "}", "/", "{", "outboundPartialDate", "}", "/", "{", "inboundPartialDate", "}", "?apiKey", "=", "{", "apiKey", "}" ]

[ "def", "create_session", "(", "self", ",", "*", "*", "params", ")", ":", "required_keys", "=", "(", "'market'", ",", "'currency'", ",", "'locale'", ",", "'pickupplace'", ",", "'dropoffplace'", ",", "'pickupdatetime'", ",", "'dropoffdatetime'", ",", "'driverage'", ")", "service_url", "=", "\"{url}/{params_path}\"", ".", "format", "(", "url", "=", "self", ".", "PRICING_SESSION_URL", ",", "params_path", "=", "self", ".", "_construct_params", "(", "params", ",", "required_keys", ")", ")", "poll_path", "=", "self", ".", "make_request", "(", "service_url", ",", "headers", "=", "self", ".", "_session_headers", "(", ")", ",", "callback", "=", "lambda", "resp", ":", "resp", ".", "headers", "[", "'location'", "]", ",", "userip", "=", "params", "[", "'userip'", "]", ")", "return", "\"{url}{path}\"", ".", "format", "(", "url", "=", "self", ".", "API_HOST", ",", "path", "=", "poll_path", ")" ]

[ "Create", "the", "session", "date", "format", ":", "YYYY", "-", "MM", "-", "DDThh", ":", "mm", "location", ":", "ISO", "code" ]

[ "def", "keyboard_field", "(", "value", ",", "args", "=", "None", ")", ":", "qs", "=", "QueryDict", "(", "args", ")", "per_line", "=", "qs", ".", "get", "(", "'per_line'", ",", "1", ")", "field", "=", "qs", ".", "get", "(", "\"field\"", ",", "\"slug\"", ")", "command", "=", "qs", ".", "get", "(", "\"command\"", ")", "convert", "=", "lambda", "element", ":", "\"/\"", "+", "command", "+", "\" \"", "+", "str", "(", "getattr", "(", "element", ",", "field", ")", ")", "group", "=", "lambda", "flat", ",", "size", ":", "[", "flat", "[", "i", ":", "i", "+", "size", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "flat", ")", ",", "size", ")", "]", "grouped", "=", "group", "(", "value", ",", "int", "(", "per_line", ")", ")", "new_list", "=", "[", "]", "for", "line", "in", "grouped", ":", "new_list", ".", "append", "(", "[", "convert", "(", "e", ")", "for", "e", "in", "line", "]", ")", "return", "str", "(", "new_list", ")", ".", "encode", "(", "'utf-8'", ")" ]

[ "Format", "keyboard", "/", "command", "field", "." ]

[ "def", "get_queryset", "(", "self", ")", ":", "if", "self", ".", "queryset", "is", "None", ":", "if", "self", ".", "model", ":", "return", "self", ".", "model", ".", "_default_manager", ".", "all", "(", ")", "else", ":", "raise", "ImproperlyConfigured", "(", "\"%(cls)s is missing a QuerySet. Define \"", "\"%(cls)s.model, %(cls)s.queryset, or override \"", "\"%(cls)s.get_queryset().\"", "%", "{", "'cls'", ":", "self", ".", "__class__", ".", "__name__", "}", ")", "return", "self", ".", "queryset", ".", "all", "(", ")" ]

[ "Return", "the", "QuerySet", "that", "will", "be", "used", "to", "look", "up", "the", "object", ".", "Note", "that", "this", "method", "is", "called", "by", "the", "default", "implementation", "of", "get_object", "and", "may", "not", "be", "called", "if", "get_object", "is", "overridden", "." ]

[ "def", "login_required", "(", "view_func", ")", ":", "@", "wraps", "(", "view_func", ")", "def", "wrapper", "(", "bot", ",", "update", ",", "*", "*", "kwargs", ")", ":", "chat", "=", "Chat", ".", "objects", ".", "get", "(", "id", "=", "update", ".", "message", ".", "chat", ".", "id", ")", "if", "chat", ".", "is_authenticated", "(", ")", ":", "return", "view_func", "(", "bot", ",", "update", ",", "*", "*", "kwargs", ")", "from", "telegrambot", ".", "bot_views", ".", "login", "import", "LoginBotView", "login_command_view", "=", "LoginBotView", ".", "as_command_view", "(", ")", "bot_model", "=", "Bot", ".", "objects", ".", "get", "(", "token", "=", "bot", ".", "token", ")", "kwargs", "[", "'link'", "]", "=", "reverse", "(", "'telegrambot:auth'", ",", "kwargs", "=", "{", "'bot'", ":", "bot_model", ".", "user_api", ".", "username", "}", ")", "return", "login_command_view", "(", "bot", ",", "update", ",", "*", "*", "kwargs", ")", "return", "wrapper" ]

[ "Decorator", "for", "command", "views", "that", "checks", "that", "the", "chat", "is", "authenticated", "sends", "message", "with", "link", "for", "authenticated", "if", "necessary", "." ]

[ "def", "pipe_util", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "pipe_util_wrapper", "(", "function", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "function", ",", "XObject", ")", ":", "function", "=", "~", "function", "original_function", "=", "function", "if", "args", "or", "kwargs", ":", "function", "=", "xpartial", "(", "function", ",", "*", "args", ",", "*", "*", "kwargs", ")", "name", "=", "lambda", ":", "'%s(%s)'", "%", "(", "get_name", "(", "func", ")", ",", "', '", ".", "join", "(", "filter", "(", "None", ",", "(", "get_name", "(", "original_function", ")", ",", "repr_args", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", ")", ")", ")", "f", "=", "func", "(", "function", ")", "result", "=", "pipe", "|", "set_name", "(", "name", ",", "f", ")", "# if the util defines an 'attrs' mapping, copy it as attributes", "# to the result", "attrs", "=", "getattr", "(", "f", ",", "'attrs'", ",", "{", "}", ")", "for", "k", ",", "v", "in", "dict_items", "(", "attrs", ")", ":", "setattr", "(", "result", ",", "k", ",", "v", ")", "return", "result", "return", "pipe_util_wrapper" ]

[ "Decorator", "that", "handles", "X", "objects", "and", "partial", "application", "for", "pipe", "-", "utils", "." ]

[ "def", "auto_string_formatter", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "auto_string_formatter_wrapper", "(", "function", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "function", ",", "string_types", ")", ":", "function", "=", "StringFormatter", "(", "function", ")", "return", "func", "(", "function", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "auto_string_formatter_wrapper" ]

[ "Decorator", "that", "handles", "automatic", "string", "formatting", "." ]

[ "def", "data_structure_builder", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "ds_builder_wrapper", "(", "function", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "function", "=", "DSBuilder", "(", "function", ")", "except", "NoBuilder", ":", "pass", "return", "func", "(", "function", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "ds_builder_wrapper" ]

[ "Decorator", "to", "handle", "automatic", "data", "structure", "creation", "for", "pipe", "-", "utils", "." ]

[ "def", "regex_condition", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "regex_condition_wrapper", "(", "condition", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "condition", ",", "string_types", ")", ":", "condition", "=", "maybe", "|", "partial", "(", "re", ".", "match", ",", "condition", ")", "return", "func", "(", "condition", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "regex_condition_wrapper" ]

[ "If", "a", "condition", "is", "given", "as", "string", "instead", "of", "a", "function", "it", "is", "turned", "into", "a", "regex", "-", "matching", "function", "." ]

[ "def", "sort_by", "(", "function", ")", ":", "f", "=", "partial", "(", "sorted", ",", "key", "=", "function", ")", "f", ".", "attrs", "=", "{", "'descending'", ":", "_descending_sort_by", "(", "function", ")", "}", "return", "f" ]

[ "Sorts", "an", "incoming", "sequence", "by", "using", "the", "given", "function", "as", "key", "." ]

[ "def", "take_first", "(", "count", ")", ":", "def", "_take_first", "(", "iterable", ")", ":", "return", "islice", "(", "iterable", ",", "count", ")", "return", "pipe", "|", "set_name", "(", "'take_first(%s)'", "%", "count", ",", "_take_first", ")" ]

[ "Assumes", "an", "iterable", "on", "the", "input", "returns", "an", "iterable", "with", "first", "count", "items", "from", "the", "input", "(", "or", "possibly", "less", "if", "there", "isn", "t", "that", "many", ")", "." ]

[ "def", "drop_first", "(", "count", ")", ":", "def", "_drop_first", "(", "iterable", ")", ":", "g", "=", "(", "x", "for", "x", "in", "range", "(", "1", ",", "count", "+", "1", ")", ")", "return", "dropwhile", "(", "lambda", "i", ":", "unless", "(", "StopIteration", ",", "lambda", ":", "next", "(", "g", ")", ")", "(", ")", ",", "iterable", ")", "return", "pipe", "|", "set_name", "(", "'drop_first(%s)'", "%", "count", ",", "_drop_first", ")" ]

[ "Assumes", "an", "iterable", "on", "the", "input", "returns", "an", "iterable", "with", "identical", "items", "except", "for", "the", "first", "count", "." ]

[ "def", "unless", "(", "exception_class_or_tuple", ",", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "@", "pipe_util", "@", "auto_string_formatter", "@", "data_structure_builder", "def", "construct_unless", "(", "function", ")", ":", "# a wrapper so we can re-use the decorators", "def", "_unless", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "return", "function", "(", "*", "args", ",", "*", "*", "kwargs", ")", "except", "exception_class_or_tuple", ":", "pass", "return", "_unless", "name", "=", "lambda", ":", "'unless(%s, %s)'", "%", "(", "exception_class_or_tuple", ",", "', '", ".", "join", "(", "filter", "(", "None", ",", "(", "get_name", "(", "func", ")", ",", "repr_args", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", ")", ")", ")", "return", "set_name", "(", "name", ",", "construct_unless", "(", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "When", "exception_class_or_tuple", "occurs", "while", "executing", "func", "it", "will", "be", "caught", "and", "None", "will", "be", "returned", "." ]

[ "def", "group_by", "(", "function", ")", ":", "def", "_group_by", "(", "seq", ")", ":", "result", "=", "{", "}", "for", "item", "in", "seq", ":", "result", ".", "setdefault", "(", "function", "(", "item", ")", ",", "[", "]", ")", ".", "append", "(", "item", ")", "return", "dict_items", "(", "result", ")", "return", "_group_by" ]

[ "Groups", "input", "sequence", "by", "function", "." ]