SYMBOL INDEX (4413 symbols across 177 files)

FILE: install_hooks.py
  function symlink_develop (line 4) | def symlink_develop(config):

FILE: mailpile/__init__.py
  class Mailpile (line 9) | class Mailpile(object):
    method __init__ (line 12) | def __init__(self,
    method _mk_action (line 39) | def _mk_action(self, cls, cmd, argspec):
    method Interact (line 55) | def Interact(self):

FILE: mailpile/__main__.py
  function main (line 5) | def main():

FILE: mailpile/app.py
  function threaded_raw_input (line 41) | def threaded_raw_input(prompt):
  function write_readline_history (line 60) | def write_readline_history(session):
  function CatchUnixSignals (line 70) | def CatchUnixSignals(session):
  function FriendlyPipeTransform (line 89) | def FriendlyPipeTransform(session, opt):
  function Interact (line 108) | def Interact(session):
  class InteractCommand (line 180) | class InteractCommand(Command):
    method command (line 186) | def command(self):
  class WaitCommand (line 216) | class WaitCommand(Command):
    method command (line 222) | def command(self):
  function Main (line 230) | def Main(args):

FILE: mailpile/auth.py
  class UserSession (line 16) | class UserSession(object):
    method __init__ (line 19) | def __init__(self, ts=None, auth=None, data=None):
    method is_expired (line 24) | def is_expired(self, now=None):
    method update_ts (line 27) | def update_ts(self):
  class UserSessionCache (line 31) | class UserSessionCache(dict):
    method delete_expired (line 32) | def delete_expired(self, now=None):
  function VerifyAndStorePassphrase (line 39) | def VerifyAndStorePassphrase(config, passphrase=None, sps=None,
  function SetLoggedIn (line 56) | def SetLoggedIn(cmd, user=None, redirect=False, session_id=None):
  function CheckPassword (line 74) | def CheckPassword(config, username, password):
  function IndirectPassword (line 81) | def IndirectPassword(config, pwd):
  function LogoutAll (line 95) | def LogoutAll():
  class Authenticate (line 100) | class Authenticate(Command):
    method RedirectBack (line 117) | def RedirectBack(cls, url, data):
    method _result (line 124) | def _result(self, result=None):
    method _error (line 131) | def _error(self, message, info=None, result=None):
    method _success (line 138) | def _success(self, message, result=None):
    method _do_redirect (line 141) | def _do_redirect(self):
    method _do_login (line 157) | def _do_login(self, user, password, load_index=False, redirect=False):
    method command (line 211) | def command(self):
  class DeAuthenticate (line 233) | class DeAuthenticate(Command):
    method command (line 243) | def command(self):
  class SetPassphrase (line 262) | class SetPassphrase(Command):
    method _get_profiles (line 287) | def _get_profiles(self):
    method _get_policy (line 290) | def _get_policy(self, fingerprint):
    method _massage_key_info (line 297) | def _massage_key_info(self, fingerprint, key_info, profiles=None, is_l...
    method _lookup_key (line 322) | def _lookup_key(self, keyid, **kwargs):
    method _list_keys (line 330) | def _list_keys(self, **kwargs):
    method _get_account (line 338) | def _get_account(self, cfg):
    method _user_fingerprint (line 344) | def _user_fingerprint(self, username):
    method _list_accounts (line 347) | def _list_accounts(self, only=None):
    method _account_details (line 372) | def _account_details(self, account):
    method _check_master_password (line 375) | def _check_master_password(self, password, account=None, fingerprint=N...
    method _check_password (line 378) | def _check_password(self, password, account=None, fingerprint=None):
    method _prepare_result (line 390) | def _prepare_result(self, account=None, keyid=None, is_locked=False):
    method command (line 404) | def command(self):

FILE: mailpile/command_cache.py
  class CommandCache (line 16) | class CommandCache(object):
    method __init__ (line 39) | def __init__(self, debug=None):
    method cache_result (line 47) | def cache_result(self, fprint, expires, req, cmd_obj, result_obj):
    method get_result (line 61) | def get_result(self, fprint, dirty_check=True, extend=300):
    method dirty_set (line 78) | def dirty_set(self, after=0):
    method mark_dirty (line 86) | def mark_dirty(self, requirements):
    method refresh (line 91) | def refresh(self, extend=0, runtime=5, event_log=None):
  class Cached (line 150) | class Cached(Command):
    method max_age (line 158) | def max_age(self):
    method run (line 164) | def run(self):

FILE: mailpile/commands.py
  class Command (line 27) | class Command(object):
    class CommandResult (line 66) | class CommandResult:
      method __init__ (line 67) | def __init__(self, command_obj, session,
      method __nonzero__ (line 95) | def __nonzero__(self):
      method as_ (line 98) | def as_(self, what, *args, **kwargs):
      method as_text (line 107) | def as_text(self):
      method as_dict (line 127) | def as_dict(self):
      method as_csv (line 158) | def as_csv(self, template=None, result=None):
      method as_json (line 171) | def as_json(self):
      method as_html (line 174) | def as_html(self, template=None):
      method as_js (line 177) | def as_js(self, template=None):
      method as_css (line 180) | def as_css(self, template=None):
      method as_rss (line 183) | def as_rss(self, template=None):
      method as_xml (line 186) | def as_xml(self, template=None):
      method as_txt (line 189) | def as_txt(self, template=None):
      method as_template (line 192) | def as_template(self, ttype,
    method __init__ (line 217) | def __init__(self, session, name=None, arg=None, data=None, async=False):
    method state_as_query_args (line 244) | def state_as_query_args(self):
    method cache_id (line 251) | def cache_id(self, sqa=None):
    method cache_requirements (line 262) | def cache_requirements(self, result):
    method cache_result (line 266) | def cache_result(self, result):
    method template_path (line 281) | def template_path(self, ttype, template_id=None, template=None):
    method _gnupg (line 296) | def _gnupg(self, **kwargs):
    method _config (line 299) | def _config(self):
    method _idx (line 309) | def _idx(self, reset=False, wait=True, wait_all=True, quiet=False):
    method _background_save (line 346) | def _background_save(self,
    method _choose_messages (line 371) | def _choose_messages(self, words, allow_ephemeral=False):
    method _error (line 418) | def _error(self, message, info=None, result=None):
    method _success (line 435) | def _success(self, message, result=True):
    method _read_file_or_data (line 444) | def _read_file_or_data(self, fn):
    method _ignore_exception (line 450) | def _ignore_exception(self):
    method _serialize (line 453) | def _serialize(self, name, function):
    method _background (line 456) | def _background(self, name, function):
    method _update_event_state (line 460) | def _update_event_state(self, state, log=False):
    method _starting (line 470) | def _starting(self):
    method _fmt_msg (line 476) | def _fmt_msg(self, message):
    method _sloppy_copy (line 481) | def _sloppy_copy(self, data, name=None):
    method _create_event (line 500) | def _create_event(self):
    method _make_command_event (line 510) | def _make_command_event(self, private_data):
    method _finishing (line 517) | def _finishing(self, rv, just_cleanup=False):
    method _update_finished_event (line 538) | def _update_finished_event(self):
    method _run_sync (line 553) | def _run_sync(self, enable_cache, *args, **kwargs):
    method _run (line 598) | def _run(self, *args, **kwargs):
    method _maybe_trigger_cache_refresh (line 624) | def _maybe_trigger_cache_refresh(self):
    method record_user_activity (line 632) | def record_user_activity(self):
    method run (line 635) | def run(self, *args, **kwargs):
    method refresh (line 656) | def refresh(self):
    method command (line 660) | def command(self):
    method etag_data (line 663) | def etag_data(self):
    method max_age (line 666) | def max_age(self):
    method view (line 670) | def view(cls, result):
  function GetCommand (line 674) | def GetCommand(name):
  function Action (line 681) | def Action(session, opt, arg, data=None):

FILE: mailpile/config/base.py
  class ConfigValueError (line 15) | class ConfigValueError(ValueError):
  function ConfigRule (line 19) | def ConfigRule(*args):
  function PublicConfigRule (line 27) | def PublicConfigRule(*args):
  function KeyConfigRule (line 33) | def KeyConfigRule(*args):
  function CriticalConfigRule (line 41) | def CriticalConfigRule(*args):
  function ConfigPrinter (line 47) | def ConfigPrinter(cfg, indent=''):
  class InvalidKeyError (line 73) | class InvalidKeyError(ValueError):
  class CommentedEscapedConfigParser (line 77) | class CommentedEscapedConfigParser(ConfigParser.RawConfigParser):
    method set (line 95) | def set(self, section, key, value, comment):
    method _decode_value (line 115) | def _decode_value(self, value):
    method get (line 121) | def get(self, section, key):
    method items (line 127) | def items(self, section):
  function _MakeCheck (line 132) | def _MakeCheck(pcls, name, comment, rules, write_watcher):
  function RuledContainer (line 141) | def RuledContainer(pcls):
  class ConfigList (line 503) | class ConfigList(RuledContainer(list)):
    method reset (line 524) | def reset(self, rules=True, data=True):
    method __createkey_and_setitem__ (line 530) | def __createkey_and_setitem__(self, key, value):
    method append (line 538) | def append(self, value):
    method __passkey__ (line 547) | def __passkey__(self, key, value):
    method __fixkey__ (line 553) | def __fixkey__(self, key):
    method get (line 561) | def get(self, key, default=None):
    method __getitem__ (line 567) | def __getitem__(self, key):
    method fmt_key (line 570) | def fmt_key(self, key):
    method iterkeys (line 574) | def iterkeys(self):
    method iteritems (line 577) | def iteritems(self):
    method keys (line 581) | def keys(self):
    method all_keys (line 584) | def all_keys(self):
    method values (line 587) | def values(self):
    method update (line 590) | def update(self, *args):
  class ConfigDict (line 599) | class ConfigDict(RuledContainer(dict)):
    method reset (line 689) | def reset(self, rules=True, data=True):
    method all_keys (line 699) | def all_keys(self):
    method append (line 703) | def append(self, value):
    method update (line 712) | def update(self, *args, **kwargs):
    method parse_config (line 724) | def parse_config(self, session, data, source='internal'):
  class PathDict (line 789) | class PathDict(ConfigDict):

FILE: mailpile/config/manager.py
  class ConfigManager (line 63) | class ConfigManager(ConfigDict):
    method __init__ (line 69) | def __init__(self, workdir=None, shareddatadir=None, rules={}):
    method create_and_lock_workdir (line 149) | def create_and_lock_workdir(self, session):
    method load (line 168) | def load(self, session, *args, **kwargs):
    method load_master_key (line 196) | def load_master_key(self, passphrase, _raise=None):
    method _load_config_lines (line 236) | def _load_config_lines(self, filename, lines):
    method _discover_plugins (line 242) | def _discover_plugins(self):
    method _configure_default_plugins (line 254) | def _configure_default_plugins(self):
    method _unlocked_load (line 266) | def _unlocked_load(self, session, public_only=False):
    method reset_rules_from_source (line 370) | def reset_rules_from_source(self):
    method load_plugins (line 378) | def load_plugins(self, session):
    method save (line 392) | def save(self, *args, **kwargs):
    method get_master_key (line 396) | def get_master_key(self):
    method set_master_key (line 418) | def set_master_key(self, key):
    method _delete_old_master_keys (line 423) | def _delete_old_master_keys(self, keyfile):
    method _save_master_key (line 437) | def _save_master_key(self, keyfile):
    method _unlocked_save (line 502) | def _unlocked_save(self, session=None, force=False):
    method _find_mail_source (line 601) | def _find_mail_source(self, mbx_id, path=None):
    method get_mailboxes (line 614) | def get_mailboxes(self, with_mail_source=None,
    method is_editable_message (line 647) | def is_editable_message(self, msg_info):
    method is_editable_mailbox (line 660) | def is_editable_mailbox(self, mailbox_id):
    method load_pickle (line 671) | def load_pickle(self, pfn, delete_if_corrupt=False):
    method save_pickle (line 692) | def save_pickle(self, obj, pfn, encrypt=True):
    method _mailbox_info (line 706) | def _mailbox_info(self, mailbox_id, prefer_local=True):
    method save_mailbox (line 722) | def save_mailbox(self, session, pfn, mbox):
    method uncache_mailbox (line 727) | def uncache_mailbox(self, session, entry, drop=True, force_save=False):
    method cache_mailbox (line 770) | def cache_mailbox(self, session, pfn, mbx_id, mbox):
    method flush_mbox_cache (line 790) | def flush_mbox_cache(self, session, clear=True, wait=False):
    method find_mboxids_and_sources_by_path (line 805) | def find_mboxids_and_sources_by_path(self, *paths):
    method open_mailbox_path (line 833) | def open_mailbox_path(self, session, path, register=False, raw_open=Fa...
    method open_mailbox (line 879) | def open_mailbox(self, session, mailbox_id,
    method create_local_mailstore (line 931) | def create_local_mailstore(self, session, name=None):
    method open_local_mailbox (line 952) | def open_local_mailbox(self, session):
    method get_passphrase (line 963) | def get_passphrase(self, keyid,
    method get_profile (line 1015) | def get_profile(self, email=None):
    method get_route (line 1056) | def get_route(self, frm, rcpts=['-t']):
    method data_directory (line 1072) | def data_directory(self, ftype, mode='rb', mkdir=False):
    method data_file_and_mimetype (line 1093) | def data_file_and_mimetype(self, ftype, fpath, *args, **kwargs):
    method history_file (line 1108) | def history_file(self):
    method mailindex_file (line 1111) | def mailindex_file(self):
    method mailpile_path (line 1114) | def mailpile_path(self, path):
    method tempfile_dir (line 1126) | def tempfile_dir(self):
    method clean_tempfile_dir (line 1132) | def clean_tempfile_dir(self):
    method postinglist_dir (line 1144) | def postinglist_dir(self, prefix):
    method need_more_disk_space (line 1153) | def need_more_disk_space(self, required=0, nodefault=False, ratio=1.0):
    method interruptable_wait_for_lock (line 1164) | def interruptable_wait_for_lock(self):
    method get_index (line 1175) | def get_index(self, session):
    method get_path_index (line 1191) | def get_path_index(self, session, path):
    method get_proxy_settings (line 1209) | def get_proxy_settings(self):
    method open_file (line 1235) | def open_file(self, ftype, fpath, mode='rb', mkdir=False):
    method daemons_started (line 1244) | def daemons_started(config, which=None):
    method get_mail_source (line 1248) | def get_mail_source(config, src_id, start=False, changed=False):
    method start_tor_worker (line 1263) | def start_tor_worker(config):
    method prepare_workers (line 1272) | def prepare_workers(self, *args, **kwargs):
    method _unlocked_prepare_workers (line 1276) | def _unlocked_prepare_workers(config, session=None, changed=False,
    method _unlocked_get_all_workers (line 1444) | def _unlocked_get_all_workers(config):
    method stop_workers (line 1453) | def stop_workers(config):
    method _unlocked_notify_workers_config_changed (line 1495) | def _unlocked_notify_workers_config_changed(config):

FILE: mailpile/config/paths.py
  function _ensure_exists (line 12) | def _ensure_exists(path, mode=0o700):
  function LEGACY_DEFAULT_WORKDIR (line 20) | def LEGACY_DEFAULT_WORKDIR(profile):
  function DEFAULT_WORKDIR (line 31) | def DEFAULT_WORKDIR():
  function DEFAULT_SHARED_DATADIR (line 51) | def DEFAULT_SHARED_DATADIR():
  function DEFAULT_LOCALE_DIRECTORY (line 80) | def DEFAULT_LOCALE_DIRECTORY():
  function LOCK_PATHS (line 85) | def LOCK_PATHS(workdir=None):

FILE: mailpile/config/validators.py
  function BoolCheck (line 18) | def BoolCheck(value):
  function SlugCheck (line 48) | def SlugCheck(slug, allow=''):
  function SlashSlugCheck (line 72) | def SlashSlugCheck(slug):
  function RouteProtocolCheck (line 82) | def RouteProtocolCheck(proto):
  function DnsNameValid (line 95) | def DnsNameValid(dnsname):
  function HostNameValid (line 104) | def HostNameValid(host):
  function HostNameCheck (line 137) | def HostNameCheck(host):
  function B36Check (line 158) | def B36Check(b36val):
  function NotUnicode (line 174) | def NotUnicode(string):
  function PathCheck (line 185) | def PathCheck(path):
  function WebRootCheck (line 205) | def WebRootCheck(path):
  function FileCheck (line 226) | def FileCheck(path=None):
  function DirCheck (line 246) | def DirCheck(path=None):
  function NewPathCheck (line 266) | def NewPathCheck(path):
  function UrlCheck (line 281) | def UrlCheck(url):
  function EmailCheck (line 304) | def EmailCheck(email):
  function GPGKeyCheck (line 316) | def GPGKeyCheck(value):
  class IgnoreValue (line 359) | class IgnoreValue(Exception):
  function IgnoreCheck (line 363) | def IgnoreCheck(data):

FILE: mailpile/conn_brokers.py
  function MonkeySockCreateConn (line 82) | def MonkeySockCreateConn(*args, **kwargs):
  function _explain_encryption (line 90) | def _explain_encryption(sock):
  class Capability (line 103) | class Capability(object):
  class CapabilityFailure (line 149) | class CapabilityFailure(IOError):
  class Url (line 163) | class Url(str):
    method __init__ (line 164) | def __init__(self, *args, **kwargs):
  class BrokeredContext (line 173) | class BrokeredContext(object):
    method __init__ (line 185) | def __init__(self, broker, need=None, reject=None, oneshot=False):
    method __str__ (line 192) | def __str__(self):
    method _reset (line 215) | def _reset(self):
    method __enter__ (line 224) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 239) | def __exit__(self, *args, **kwargs):
  class BaseConnectionBroker (line 243) | class BaseConnectionBroker(Capability):
    method __init__ (line 249) | def __init__(self, master=None):
    method configure (line 255) | def configure(self):
    method set_config (line 258) | def set_config(self, config):
    method config (line 262) | def config(self):
    method _raise_or_none (line 269) | def _raise_or_none(self, exc, why):
    method _check (line 274) | def _check(self, need, reject, _raise=CapabilityFailure):
    method _describe (line 289) | def _describe(self, context, conn):
    method debug (line 292) | def debug(self, val):
    method context (line 296) | def context(self, need=None, reject=None, oneshot=False):
    method create_conn_with_caps (line 299) | def create_conn_with_caps(self, address, context, need, reject,
    method create_connection (line 307) | def create_connection(self, address, *args, **kwargs):
    method _create_connection (line 319) | def _create_connection(self, context, address, *args, **kwargs):
    method get_urls (line 322) | def get_urls(self, listening_fd,
    method _get_urls (line 330) | def _get_urls(self, listening_fd,
  class TcpConnectionBroker (line 335) | class TcpConnectionBroker(BaseConnectionBroker):
    method configure (line 352) | def configure(self):
    method _describe (line 357) | def _describe(self, context, conn):
    method _in_no_proxy_list (line 370) | def _in_no_proxy_list(self, address):
    method _avoid (line 376) | def _avoid(self, address):
    method _broker_avoid (line 383) | def _broker_avoid(self, address):
    method _conn (line 387) | def _conn(self, address, *args, **kwargs):
    method _create_connection (line 392) | def _create_connection(self, context, address, *args, **kwargs):
  class SocksConnBroker (line 400) | class SocksConnBroker(TcpConnectionBroker):
    method _describe (line 418) | def _describe(self, context, conn):
    method __init__ (line 423) | def __init__(self, *args, **kwargs):
    method configure (line 428) | def configure(self):
    method _auth_args (line 444) | def _auth_args(self):
    method _avoid (line 449) | def _avoid(self, address):
    method _fix_address_tuple (line 454) | def _fix_address_tuple(self, address):
    method _conn (line 457) | def _conn(self, address, timeout=None, source_address=None, **kwargs):
  class TorConnBroker (line 482) | class TorConnBroker(SocksConnBroker):
    method _describe (line 505) | def _describe(self, context, conn):
    method _auth_args (line 510) | def _auth_args(self):
    method _fix_address_tuple (line 515) | def _fix_address_tuple(self, address):
    method _broker_avoid (line 519) | def _broker_avoid(self, address):
  class TorRiskyBroker (line 524) | class TorRiskyBroker(TorConnBroker):
  class TorOnionBroker (line 537) | class TorOnionBroker(TorConnBroker):
    method _broker_avoid (line 555) | def _broker_avoid(self, address):
  class BaseConnectionBrokerProxy (line 561) | class BaseConnectionBrokerProxy(TcpConnectionBroker):
    method _proxy_address (line 570) | def _proxy_address(self, address):
    method _proxy (line 573) | def _proxy(self, conn):
    method _wrap_ssl (line 576) | def _wrap_ssl(self, conn):
    method _create_connection (line 581) | def _create_connection(self, context, address, *args, **kwargs):
  class AutoTlsConnBroker (line 593) | class AutoTlsConnBroker(BaseConnectionBrokerProxy):
    method _describe (line 603) | def _describe(self, context, conn):
    method _proxy_address (line 607) | def _proxy_address(self, address):
    method _proxy (line 615) | def _proxy(self, conn):
  class AutoSmtpStartTLSConnBroker (line 619) | class AutoSmtpStartTLSConnBroker(BaseConnectionBrokerProxy):
  class AutoImapStartTLSConnBroker (line 623) | class AutoImapStartTLSConnBroker(BaseConnectionBrokerProxy):
  class AutoPop3StartTLSConnBroker (line 627) | class AutoPop3StartTLSConnBroker(BaseConnectionBrokerProxy):
  class MasterBroker (line 631) | class MasterBroker(BaseConnectionBroker):
    method __init__ (line 639) | def __init__(self, *args, **kwargs):
    method configure (line 646) | def configure(self):
    method _debugger (line 650) | def _debugger(self, *args, **kwargs):
    method register_broker (line 654) | def register_broker(self, priority, cb):
    method get_fd_context (line 669) | def get_fd_context(self, fileno):
    method create_conn_with_caps (line 675) | def create_conn_with_caps(self, address, context, need, reject,
    method get_urls (line 710) | def get_urls(self, listening_fd, need=None, reject=None):
  function DisableUnbrokeredConnections (line 717) | def DisableUnbrokeredConnections():
  class NetworkHistory (line 727) | class NetworkHistory(Command):
    class CommandResult (line 734) | class CommandResult(Command.CommandResult):
      method as_text (line 735) | def as_text(self):
    method command (line 743) | def command(self):
  class GetTlsCertificate (line 748) | class GetTlsCertificate(Command):
    class CommandResult (line 761) | class CommandResult(Command.CommandResult):
      method as_text (line 762) | def as_text(self):
    method command (line 769) | def command(self):
  function SslWrapOnlyOnce (line 991) | def SslWrapOnlyOnce(org_sslwrap, sock, *args, **kwargs):
  function SslContextWrapOnlyOnce (line 1009) | def SslContextWrapOnlyOnce(org_ctxwrap, self, sock, *args, **kwargs):

FILE: mailpile/crypto/aes_utils.py
  function make_cryptography_utils (line 20) | def make_cryptography_utils():
  function make_pycrypto_utils (line 54) | def make_pycrypto_utils():
  function make_dummy_utils (line 88) | def make_dummy_utils():
  function getrandbits (line 109) | def getrandbits(count):
  function aes_ctr_encrypt (line 117) | def aes_ctr_encrypt(key, iv, data):
  function aes_ctr_decrypt (line 120) | def aes_ctr_decrypt(key, iv, data):

FILE: mailpile/crypto/autocrypt.py
  function canonicalize_email (line 99) | def canonicalize_email(address):
  function parse_autocrypt_headervalue (line 122) | def parse_autocrypt_headervalue(value, optional_attrs=None):
  function extract_autocrypt_header (line 170) | def extract_autocrypt_header(msg, to=None, optional_attrs=None):
  function extract_autocrypt_gossip_headers (line 201) | def extract_autocrypt_gossip_headers(msg, to=None, optional_attrs=None):
  function make_autocrypt_header (line 212) | def make_autocrypt_header(addr, binary_key,
  function generate_autocrypt_setup_code (line 223) | def generate_autocrypt_setup_code(random_data=None):
  function UNUSED_get_minimal_PGP_key (line 249) | def UNUSED_get_minimal_PGP_key(keydata,
  class AutocryptRecommendation (line 426) | class AutocryptRecommendation(object):
    method __init__ (line 434) | def __init__(self, policy, key_sig=None):
    method __str__ (line 438) | def __str__(self):
    method Synchronize (line 444) | def Synchronize(cls, *recommendations):
    method set_recommendation (line 457) | def set_recommendation(self, policy, key_sig=None):

FILE: mailpile/crypto/gpgi.py
  class GnuPGEventUpdater (line 59) | class GnuPGEventUpdater:
    method __init__ (line 63) | def __init__(self, event):
    method _log (line 67) | def _log(self, section, message):
    method _log_private (line 72) | def _log_private(self, message):
    method _log_public (line 75) | def _log_public(self, message):
    method running_gpg (line 79) | def running_gpg(self, why):
    method update_args (line 85) | def update_args(self, args):
    method update_sent_passphrase (line 88) | def update_sent_passphrase(self):
    method _parse_gpg_line (line 91) | def _parse_gpg_line(self, line):
    method update_stdout (line 97) | def update_stdout(self, line):
    method update_stderr (line 100) | def update_stderr(self, line):
    method update_return_code (line 103) | def update_return_code(self, code):
  class GnuPGResultParser (line 107) | class GnuPGResultParser:
    method __init__ (line 111) | def __init__(rp, decrypt_requires_MDC=True, debug=None):
    method parse (line 123) | def parse(rp, retvals):
  class GnuPGRecordParser (line 247) | class GnuPGRecordParser:
    method __init__ (line 248) | def __init__(self):
    method parse (line 270) | def parse(self, lines):
    method parse_line (line 275) | def parse_line(self, line):
    method _parse_dates (line 282) | def _parse_dates(self, line):
    method _parse_keydata (line 294) | def _parse_keydata(self, line):
    method _clean_curdata (line 311) | def _clean_curdata(self):
    method parse_pubkey (line 317) | def parse_pubkey(self, line):
    method parse_subkey (line 326) | def parse_subkey(self, line):
    method parse_fingerprint (line 331) | def parse_fingerprint(self, line):
    method parse_userattribute (line 339) | def parse_userattribute(self, line):
    method parse_privkey (line 345) | def parse_privkey(self, line):
    method parse_uidline (line 348) | def parse_uidline(self, line):
    method parse_trust (line 364) | def parse_trust(self, line):
    method parse_signature (line 368) | def parse_signature(self, line):
    method parse_keygrip (line 382) | def parse_keygrip(self, line):
    method parse_revoke (line 385) | def parse_revoke(self, line):
    method parse_revocation_key (line 388) | def parse_revocation_key(self, line):
    method parse_unknown (line 391) | def parse_unknown(self, line):
    method parse_none (line 394) | def parse_none(line):
  function stubborn_decode (line 401) | def stubborn_decode(text):
  function parse_uid (line 413) | def parse_uid(uidstr):
  class StreamReader (line 429) | class StreamReader(Thread):
    method __init__ (line 430) | def __init__(self, name, fd, callback, lines=True):
    method __str__ (line 437) | def __str__(self):
    method readin (line 441) | def readin(self, fd, callback):
  class StreamWriter (line 464) | class StreamWriter(Thread):
    method __init__ (line 465) | def __init__(self, name, fd, output, partial_write_ok=False):
    method __str__ (line 472) | def __str__(self):
    method writeout (line 475) | def writeout(self, fd, output):
  class GnuPG (line 502) | class GnuPG:
    method __init__ (line 519) | def __init__(self, config,
    method prepare_passphrase (line 552) | def prepare_passphrase(self, keyid, signing=False, decrypting=False):
    method _debug_all (line 574) | def _debug_all(self, msg):
    method _debug_none (line 580) | def _debug_none(self, msg):
    method set_home (line 583) | def set_home(self, path):
    method version (line 586) | def version(self):
    method version_tuple (line 592) | def version_tuple(self, update=False):
    method gnupghome (line 601) | def gnupghome(self):
    method is_available (line 610) | def is_available(self):
    method common_args (line 620) | def common_args(self,
    method run (line 673) | def run(self, *args, **kwargs):
    method run_without_status (line 685) | def run_without_status(self,
    method _reap_threads (line 778) | def _reap_threads(self):
    method parse_status (line 786) | def parse_status(self, line, *args):
    method parse_stdout (line 794) | def parse_stdout(self, line):
    method parse_stderr (line 799) | def parse_stderr(self, line):
    method parse_keylist (line 804) | def parse_keylist(self, keylist):
    method list_keys (line 808) | def list_keys(self, selectors=None):
    method list_secret_keys (line 824) | def list_secret_keys(self, selectors=None):
    method import_keys (line 871) | def import_keys(self,
    method _parse_import (line 892) | def _parse_import(self, output):
    method decrypt (line 948) | def decrypt(self, data,
    method base64_segment (line 1001) | def base64_segment(self, dec_start, dec_end, skip, line_len, line_end ...
    method pgp_packet_hdr_parse (line 1018) | def pgp_packet_hdr_parse(self, header, prev_partial = False):
    method sniff (line 1089) | def sniff(self, data, encoding = None):
    method remove_armor (line 1223) | def remove_armor(self, text):
    method verify (line 1234) | def verify(self, data, signature=None):
    method encrypt (line 1256) | def encrypt(self, data, tokeys=[], armor=True,
    method sign (line 1294) | def sign(self, data,
    method sign_key (line 1326) | def sign_key(self, keyid, signingkey=None):
    method delete_key (line 1338) | def delete_key(self, key_fingerprint):
    method recv_key (line 1342) | def recv_key(self, keyid,
    method parse_hpk_response (line 1359) | def parse_hpk_response(self, lines):
    method search_key (line 1389) | def search_key(self, term,
    method get_pubkey (line 1405) | def get_pubkey(self, keyid):
    method get_minimal_key (line 1408) | def get_minimal_key(self, key_id=None, user_id=None, armor=True):
    method export_pubkeys (line 1424) | def export_pubkeys(self, selectors=None, armor=True, extra_args=[]):
    method export_privkeys (line 1433) | def export_privkeys(self, selectors=None):
    method address_to_keys (line 1439) | def address_to_keys(self, address):
    method _escape_hex_keyid_term (line 1448) | def _escape_hex_keyid_term(self, term):
    method chat (line 1464) | def chat(self, gpg_args, callback, *args, **kwargs):
  function GetKeys (line 1494) | def GetKeys(gnupg, config, people):
  class OpenPGPMimeSigningWrapper (line 1559) | class OpenPGPMimeSigningWrapper(MimeSigningWrapper):
    method crypto (line 1565) | def crypto(self):
    method get_keys (line 1568) | def get_keys(self, who):
  class OpenPGPMimeEncryptingWrapper (line 1572) | class OpenPGPMimeEncryptingWrapper(MimeEncryptingWrapper):
    method crypto (line 1579) | def crypto(self):
    method get_keys (line 1582) | def get_keys(self, who):
  class OpenPGPMimeSignEncryptWrapper (line 1586) | class OpenPGPMimeSignEncryptWrapper(OpenPGPMimeEncryptingWrapper):
    method crypto (line 1591) | def crypto(self):
    method _encrypt (line 1594) | def _encrypt(self, message_text, tokeys=None, armor=False):
    method _update_crypto_status (line 1601) | def _update_crypto_status(self, part):
  class GnuPGExpectScript (line 1606) | class GnuPGExpectScript(threading.Thread):
    method __init__ (line 1619) | def __init__(self, gnupg,
    method __str__ (line 1636) | def __str__(self):
    method in_state (line 1642) | def in_state(self, state):
    method set_state (line 1645) | def set_state(self, state):
    method sendline (line 1649) | def sendline(self, proc, line):
    method _expecter (line 1668) | def _expecter(self, proc, exp, timebox):
    method expect_exact (line 1686) | def expect_exact(self, proc, exp, timeout=None):
    method run_script (line 1705) | def run_script(self, proc, script):
    method gpg_args (line 1716) | def gpg_args(self):
    method run (line 1719) | def run(self):
    method on_complete (line 1737) | def on_complete(self, name, callback):
  class GnuPGBaseKeyGenerator (line 1746) | class GnuPGBaseKeyGenerator(GnuPGExpectScript):
    method __init__ (line 1769) | def __init__(self, *args, **kwargs):
    method in_state (line 1773) | def in_state(self, state):
    method run (line 1777) | def run(self):
  class GnuPG14KeyGenerator (line 1790) | class GnuPG14KeyGenerator(GnuPGBaseKeyGenerator):
    method gpg_args (line 1811) | def gpg_args(self):
  class GnuPG21RSAKeyGenerator (line 1815) | class GnuPG21RSAKeyGenerator(GnuPG14KeyGenerator):
    method sendline (line 1834) | def sendline(self, proc, line):
    method gpg_args (line 1839) | def gpg_args(self):
  class GnuPG21Curve25519KeyGenerator (line 1845) | class GnuPG21Curve25519KeyGenerator(GnuPG21RSAKeyGenerator):
  class GnuPGDummyKeyGenerator (line 1865) | class GnuPGDummyKeyGenerator(GnuPGBaseKeyGenerator):
    method __init__ (line 1870) | def __init__(self, *args, **kwargs):
    method run (line 1874) | def run(self):
  function GnuPGKeyGenerator (line 1883) | def GnuPGKeyGenerator(gnupg, **kwargs):

FILE: mailpile/crypto/keyinfo.py
  function monkey_patch_pgpdump (line 13) | def monkey_patch_pgpdump():
  class ustr (line 38) | class ustr(str):
    method __new__ (line 39) | def __new__(cls, content):
  class RestrictedDict (line 43) | class RestrictedDict(dict):
    method prep_properties (line 47) | def prep_properties(cls):
    method __init__ (line 53) | def __init__(self, *args, **kwargs):
    method keys (line 62) | def keys(self):
    method __setitem__ (line 68) | def __setitem__(self, item, value):
    method __getitem__ (line 89) | def __getitem__(self, item):
  class KeyUID (line 96) | class KeyUID(RestrictedDict):
    method __repr__ (line 102) | def __repr__(self):
  class KeyInfo (line 113) | class KeyInfo(RestrictedDict):
    method summary (line 144) | def summary(self, full_fingerprint=False):
    method __repr__ (line 162) | def __repr__(self):
    method ensure_autocrypt_uid (line 169) | def ensure_autocrypt_uid(keyinfo, ac_uid):
    method add_subkey_capabilities (line 181) | def add_subkey_capabilities(keyinfo, now=None):
    method synthesize_validity (line 194) | def synthesize_validity(keyinfo, now=None):
    method recalculate_expiration (line 202) | def recalculate_expiration(keyinfo, now=None):
    method FromGPGI (line 221) | def FromGPGI(cls, gpgi_keyinfo):
  class MailpileKeyInfo (line 241) | class MailpileKeyInfo(KeyInfo):
  function get_keyinfo (line 260) | def get_keyinfo(data, autocrypt_header=None,

FILE: mailpile/crypto/mime.py
  function Normalize (line 22) | def Normalize(payload):
  function MessageAsString (line 39) | def MessageAsString(part, unixfrom=False):
  class EncryptionFailureError (line 45) | class EncryptionFailureError(ValueError):
    method __init__ (line 46) | def __init__(self, message, to_keys):
  class SignatureFailureError (line 51) | class SignatureFailureError(ValueError):
    method __init__ (line 52) | def __init__(self, message, from_key):
  function _decode_text_part (line 60) | def _decode_text_part(part, payload, charsets=None):
  function _update_text_payload (line 70) | def _update_text_payload(part, payload, charsets=None):
  function MimeAttachmentDisposition (line 81) | def MimeAttachmentDisposition(part, kind, newpart):
  function MimeReplacePart (line 109) | def MimeReplacePart(part, newpart, keep_old_headers=False):
  function UnwrapMimeCrypto (line 152) | def UnwrapMimeCrypto(part, protocols=None, psi=None, pei=None, charsets=...
  function UnwrapPlainTextCrypto (line 387) | def UnwrapPlainTextCrypto(part, protocols=None, psi=None, pei=None,
  function ObscureSubject (line 434) | def ObscureSubject(subject):
  function ObscureNames (line 441) | def ObscureNames(hdr):
  function ObscureSender (line 453) | def ObscureSender(sender):
  function ObscureAllRecipients (line 460) | def ObscureAllRecipients(sender):
  class MimeWrapper (line 509) | class MimeWrapper:
    method __init__ (line 527) | def __init__(self, config,
    method crypto (line 558) | def crypto(self):
    method attach (line 561) | def attach(self, part):
    method get_keys (line 579) | def get_keys(self, people):
    method flatten (line 582) | def flatten(self, msg, unixfrom=False):
    method get_only_text_part (line 585) | def get_only_text_part(self, msg):
    method wrap (line 599) | def wrap(self, msg, **kwargs):
    method prepare_wrap (line 603) | def prepare_wrap(self, msg):
    method force_display_headers (line 637) | def force_display_headers(self, msg, obscured_set):
  class MimeSigningWrapper (line 680) | class MimeSigningWrapper(MimeWrapper):
    method __init__ (line 686) | def __init__(self, *args, **kwargs):
    method _wrap_sig_in_html (line 699) | def _wrap_sig_in_html(self, sig):
    method _wrap_sig_in_html_vars (line 706) | def _wrap_sig_in_html_vars(self, sig):
    method _update_crypto_status (line 721) | def _update_crypto_status(self, part):
    method wrap (line 724) | def wrap(self, msg, prefer_inline=False):
  class MimeEncryptingWrapper (line 761) | class MimeEncryptingWrapper(MimeWrapper):
    method __init__ (line 767) | def __init__(self, *args, **kwargs):
    method _encrypt (line 783) | def _encrypt(self, message_text, tokeys=None, armor=False):
    method _update_crypto_status (line 787) | def _update_crypto_status(self, part):
    method _add_padding (line 790) | def _add_padding(self, text, chunksize=None):
    method wrap (line 799) | def wrap(self, msg, prefer_inline=False):

FILE: mailpile/crypto/records.py
  class _SimpleList (line 128) | class _SimpleList(object):
    method append (line 130) | def append(self, value):
    method extend (line 136) | def extend(self, values):
    method __getslice__ (line 140) | def __getslice__(self, i, j):
    method __iadd__ (line 143) | def __iadd__(self, y):
    method __iter__ (line 146) | def __iter__(self):
    method __reversed__ (line 149) | def __reversed__(self):
  class EncryptedRecordStore (line 153) | class EncryptedRecordStore(_SimpleList):
    method __init__ (line 170) | def __init__(self, fn, key,
    method _calculate_constants (line 199) | def _calculate_constants(self):
    method _parse_header (line 212) | def _parse_header(self):
    method _write_header (line 245) | def _write_header(self):
    method close (line 254) | def close(self):
    method _iv (line 258) | def _iv(self, pos):
    method save_record (line 276) | def save_record(self, pos, data):
    method save_zeros (line 310) | def save_zeros(self, pos, count):
    method load_record (line 318) | def load_record(self, pos):
    method __getitem__ (line 353) | def __getitem__(self, pos):
    method __setitem__ (line 359) | def __setitem__(self, pos, data):
    method get (line 362) | def get(self, pos, default=None):
    method __len__ (line 368) | def __len__(self):
  class EncryptedBlobStore (line 375) | class EncryptedBlobStore(_SimpleList):
    method __init__ (line 386) | def __init__(self, base_fn, key,
    method _big (line 408) | def _big(self):
    method _next_shardname (line 420) | def _next_shardname(self):
    method _load_next_shard (line 423) | def _load_next_shard(self):
    method __getitem__ (line 431) | def __getitem__(self, pos):
    method __setitem__ (line 440) | def __setitem__(self, pos, data):
    method __len__ (line 453) | def __len__(self):
    method close (line 458) | def close(self):
  class EncryptedUnicodeStore (line 468) | class EncryptedUnicodeStore(EncryptedBlobStore):
    method __setitem__ (line 472) | def __setitem__(self, pos, data):
    method __getitem__ (line 475) | def __getitem__(self, pos):
  class EncryptedDict (line 479) | class EncryptedDict(object):
    method __init__ (line 502) | def __init__(self, base_fn, key,
    method reset_counters (line 547) | def reset_counters(self):
    method _keyfile_size (line 553) | def _keyfile_size(self, kfi):
    method _keyfile_bytes (line 556) | def _keyfile_bytes(self, kfi):
    method _next_keyfile (line 559) | def _next_keyfile(self):
    method _load_next_keys (line 563) | def _load_next_keys(self):
    method _digest (line 585) | def _digest(self, key):
    method _offset (line 594) | def _offset(self, digest):
    method _offset_and_digest (line 597) | def _offset_and_digest(self, key):
    method load_records (line 601) | def load_records(self, kfi, keyset, count, pos, want=[]):
    method load_record (line 617) | def load_record(self, key, **kwargs):
    method load_digest_record (line 620) | def load_digest_record(self, digest, want=None):
    method _try_save (line 635) | def _try_save(self, kfi, keyset, pos, digest, value, on_fail=None):
    method save_digest_record (line 675) | def save_digest_record(self, digest, value, on_fail=None):
    method save_record (line 695) | def save_record(self, key, value, on_fail=None):
    method __setitem__ (line 699) | def __setitem__(self, key, value):
    method __contains__ (line 702) | def __contains__(self, key):
    method __delitem__ (line 709) | def __delitem__(self, key):
    method values (line 716) | def values(self):
    method rdata_digest (line 724) | def rdata_digest(self, rdata):
    method rdata_value (line 727) | def rdata_value(self, rdata):
    method __getitem__ (line 736) | def __getitem__(self, key):
    method get (line 743) | def get(self, key, default=None, **kwargs):
    method close (line 749) | def close(self):
  class EncryptedUnicodeDict (line 756) | class EncryptedUnicodeDict(EncryptedDict):
    method save_record (line 760) | def save_record(self, key, value):
    method rdata_value (line 764) | def rdata_value(self, rdata):
  class EncryptedIntDict (line 769) | class EncryptedIntDict(EncryptedDict):
    method keys (line 777) | def keys(self):
    method save_record (line 786) | def save_record(self, key, value):
    method rdata_value (line 791) | def rdata_value(self, rdata):

FILE: mailpile/crypto/state.py
  class KeyLookupError (line 9) | class KeyLookupError(ValueError):
    method __init__ (line 10) | def __init__(self, message, missing):
  class CryptoInfo (line 24) | class CryptoInfo(dict):
    method __init__ (line 30) | def __init__(self, parent=None, copy=None, bubbly=True):
    method _set_status (line 49) | def _set_status(self, value):
    method __setitem__ (line 56) | def __setitem__(self, item, value):
    method _overwrite_with (line 67) | def _overwrite_with(self, ci):
    method bubble_up (line 72) | def bubble_up(self, parent=None):
    method mix_bubbles (line 88) | def mix_bubbles(self):
    method _mix_in (line 96) | def _mix_in(self, ci):
  class EncryptionInfo (line 120) | class EncryptionInfo(CryptoInfo):
  class SignatureInfo (line 129) | class SignatureInfo(CryptoInfo):

FILE: mailpile/crypto/streamer.py
  function mac_sha256 (line 88) | def mac_sha256(key, data):
  class IOFilter (line 94) | class IOFilter(threading.Thread):
    method __init__ (line 101) | def __init__(self, fd, callback,
    method __str__ (line 126) | def __str__(self):
    method __enter__ (line 129) | def __enter__(self):
    method __exit__ (line 132) | def __exit__(self, exc_type, exc_val, exc_tb):
    method close (line 135) | def close(self):
    method join (line 148) | def join(self, aborting=None):
    method writer (line 153) | def writer(self):
    method reader (line 165) | def reader(self):
    method _copy_loop (line 178) | def _copy_loop(self):
    method run (line 191) | def run(self):
  class ReadLineIOFilter (line 221) | class ReadLineIOFilter(IOFilter):
    method __init__ (line 226) | def __init__(self, fd, callback,
    method _maybe_flush (line 233) | def _maybe_flush(self, eof=False):
    method _copy_loop (line 247) | def _copy_loop(self):
  class IOCoprocess (line 265) | class IOCoprocess(object):
    method __init__ (line 266) | def __init__(self, command, fd, name=None, long_running=False):
    method __enter__ (line 283) | def __enter__(self):
    method __exit__ (line 286) | def __exit__(self, exc_type, exc_val, exc_tb):
    method close (line 289) | def close(self, *args):
  class OutputCoprocess (line 318) | class OutputCoprocess(IOCoprocess):
    method _popen (line 322) | def _popen(self, command, fd, long_running):
    method _write_filter (line 327) | def _write_filter(self, data):
    method write (line 330) | def write(self, data, *args, **kwargs):
    method flush (line 333) | def flush(self):
  class InputCoprocess (line 337) | class InputCoprocess(IOCoprocess):
    method _popen (line 341) | def _popen(self, command, fd, long_running):
    method _read_filter (line 347) | def _read_filter(self, data):
    method __iter__ (line 350) | def __iter__(self, *args):
    method readline (line 353) | def readline(self, *args):
    method readlines (line 356) | def readlines(self, *args):
    method read (line 359) | def read(self, *args):
  class ChecksummingStreamer (line 363) | class ChecksummingStreamer(OutputCoprocess):
    method __init__ (line 370) | def __init__(self, dir=None, name=None, long_running=False,
    method _mk_tempfile_and_path (line 404) | def _mk_tempfile_and_path(self, _dir):
    method _mk_command (line 408) | def _mk_command(self):
    method finish (line 411) | def finish(self):
    method close (line 433) | def close(self):
    method save (line 437) | def save(self, filename, finish=True, mode='wb'):
    method calculate_outer_sha256 (line 469) | def calculate_outer_sha256(self):
    method outer_mac_sha256 (line 480) | def outer_mac_sha256(self):
    method save_copy (line 484) | def save_copy(self, ofd):
    method _sha256_callback (line 491) | def _sha256_callback(self, data):
    method _write_preamble (line 502) | def _write_preamble(self):
    method _write_postamble (line 505) | def _write_postamble(self):
  class EncryptingDelimitedStreamer (line 509) | class EncryptingDelimitedStreamer(ChecksummingStreamer):
    method __init__ (line 523) | def __init__(self, key,
    method _write_filter (line 570) | def _write_filter(self, data):
    method _sha256_callback (line 588) | def _sha256_callback(self, data):
    method outer_mac_sha256 (line 591) | def outer_mac_sha256(self):
    method write_pad_and_flush (line 594) | def write_pad_and_flush(self, data, pad=' '):
    method finish (line 604) | def finish(self, *args, **kwargs):
    method _write_inner_sha256 (line 614) | def _write_inner_sha256(self):
    method _nonce_and_mutated_key (line 629) | def _nonce_and_mutated_key(self, key):
    method _send_key (line 638) | def _send_key(self):
    method _mk_command (line 644) | def _mk_command(self):
    method _write_preamble (line 650) | def _write_preamble(self):
    method _write_postamble (line 661) | def _write_postamble(self):
  class EncryptingUndelimitedStreamer (line 668) | class EncryptingUndelimitedStreamer(EncryptingDelimitedStreamer):
  function EncryptingStreamer (line 681) | def EncryptingStreamer(*args, **kwargs):
  class DecryptingStreamer (line 691) | class DecryptingStreamer(InputCoprocess):
    method StartEncrypted (line 712) | def StartEncrypted(cls, line):
    method EndEncrypted (line 718) | def EndEncrypted(cls, line):
    method __init__ (line 722) | def __init__(self, fd,
    method _read_filter (line 768) | def _read_filter(self, data):
    method close (line 776) | def close(self):
    method verify (line 781) | def verify(self, testing=False, _raise=None):
    method _mk_data_filter (line 820) | def _mk_data_filter(self, fd, cb, ecb):
    method _read_data (line 824) | def _read_data(self, data):
    method _mutate_key (line 985) | def _mutate_key(self, key, nonce):
    method _mk_command (line 988) | def _mk_command(self):
  class PartialDecryptingStreamer (line 1003) | class PartialDecryptingStreamer(DecryptingStreamer):
    method __init__ (line 1004) | def __init__(self, start_data, *args, **kwargs):
    method _mk_data_filter (line 1008) | def _mk_data_filter(self, fd, cb, ecb):
  function _assert (line 1020) | def _assert(val, want=True, msg='assert'):
  function fdcheck (line 1060) | def fdcheck(where):
  function counter (line 1076) | def counter(data):

FILE: mailpile/crypto/tor.py
  function debug (line 25) | def debug( text ):
  class Tor (line 34) | class Tor(threading.Thread):
    method __new__ (line 36) | def __new__(cls, *args, **kwargs):
    method __init__ (line 41) | def __init__(self, session=None, config=None,
    method run (line 73) | def run(self):
    method _run_once (line 85) | def _run_once(self):
    method _hashed_control_password (line 150) | def _hashed_control_password(self):
    method _log_line (line 164) | def _log_line(self, line, notify=False):
    method relaunch_hidden_services (line 183) | def relaunch_hidden_services(self):
    method launch_hidden_service (line 191) | def launch_hidden_service(self, portmap, key_type=None, key_content=No...
    method stop_tor (line 207) | def stop_tor(self, wait=True):
    method isReady (line 225) | def isReady(self, wait=False):
    method isAlive (line 239) | def isAlive(self):
    method quit (line 243) | def quit(self, join=True):

FILE: mailpile/eventlog.py
  function NewEventId (line 22) | def NewEventId():
  function _ClassName (line 34) | def _ClassName(obj, ignore_regexps=False):
  class Event (line 48) | class Event(object):
    method Parse (line 66) | def Parse(cls, json_string):
    method __init__ (line 72) | def __init__(self,
    method __str__ (line 86) | def __str__(self):
    method _set_ts (line 89) | def _set_ts(self, ts):
    method _set (line 98) | def _set(self, col, value):
    method _get_source_class (line 102) | def _get_source_class(self):
    method as_dict (line 125) | def as_dict(self, private=True):
    method as_text (line 142) | def as_text(self, private=True, compact=False):
    method as_json (line 155) | def as_json(self, private=True):
    method as_html (line 161) | def as_html(self, private=True):
  function GetThreadEvent (line 171) | def GetThreadEvent(create=False, message=None, source=None):
  class EventLog (line 181) | class EventLog(object):
    method __init__ (line 193) | def __init__(self, logdir, decryption_key_func, encryption_key_func,
    method _notify_waiters (line 208) | def _notify_waiters(self):
    method wait (line 212) | def wait(self, timeout=None):
    method _save_filename (line 216) | def _save_filename(self):
    method _open_log (line 219) | def _open_log(self):
    method _maybe_rotate_log (line 247) | def _maybe_rotate_log(self):
    method _list_logfiles (line 257) | def _list_logfiles(self):
    method _save_events (line 261) | def _save_events(self, events, recursed=False):
    method _load_logfile (line 276) | def _load_logfile(self, lfn):
    method _match (line 292) | def _match(self, event, filters):
    method incomplete (line 334) | def incomplete(self, **filters):
    method since (line 347) | def since(self, ts, **filters):
    method events (line 362) | def events(self, **filters):
    method get (line 365) | def get(self, event_id, default=None):
    method log_event (line 368) | def log_event(self, event):
    method log (line 379) | def log(self, *args, **kwargs):
    method close (line 383) | def close(self):
    method _unlocked_close (line 387) | def _unlocked_close(self):
    method _prune_completed (line 394) | def _prune_completed(self):
    method ui_watch (line 399) | def ui_watch(self, ui):
    method ui_unwatch (line 408) | def ui_unwatch(self, ui):
    method load (line 416) | def load(self):
    method purge_old_logfiles (line 429) | def purge_old_logfiles(self, keep=None):

FILE: mailpile/httpd.py
  function Idle_HTTPD (line 38) | def Idle_HTTPD(allowed=1):
  class HttpRequestHandler (line 49) | class HttpRequestHandler(SimpleXMLRPCRequestHandler):
    method assert_no_newline (line 86) | def assert_no_newline(self, data):
    method assert_no_html (line 90) | def assert_no_html(self, data):
    method send_header (line 94) | def send_header(self, hdr, value):
    method http_host (line 98) | def http_host(self):
    method _load_cookies (line 106) | def _load_cookies(self):
    method http_session (line 117) | def http_session(self):
    method server_url (line 127) | def server_url(self):
    method send_http_response (line 137) | def send_http_response(self, code, msg):
    method send_http_redirect (line 143) | def send_http_redirect(self, destination):
    method send_standard_headers (line 157) | def send_standard_headers(self,
    method send_full_response (line 198) | def send_full_response(self, message,
    method guess_mimetype (line 233) | def guess_mimetype(self, fpath):
    method _mk_etag (line 239) | def _mk_etag(self, *args):
    method _maybe_gzip (line 246) | def _maybe_gzip(self, data, msg_size, headers):
    method send_file (line 265) | def send_file(self, config, filename, suppress_body=False):
    method do_POST (line 304) | def do_POST(self, method='POST'):
    method do_GET (line 343) | def do_GET(self, *args, **kwargs):
    method _real_do_GET (line 360) | def _real_do_GET(self, post_data={}, suppress_body=False, method='GET'):
    method do_PUT (line 525) | def do_PUT(self):
    method do_UPDATE (line 528) | def do_UPDATE(self):
    method do_HEAD (line 531) | def do_HEAD(self):
    method log_message (line 534) | def log_message(self, fmt, *args):
  class HttpServer (line 540) | class HttpServer(SocketServer.ThreadingMixIn, SimpleXMLRPCServer):
    method __init__ (line 541) | def __init__(self, session, sspec, handler):
    method serve_forever (line 572) | def serve_forever(self, poll_interval=0.5, tick_func=None):
    method shutdown (line 594) | def shutdown(self, join=True):
    method make_session_id (line 600) | def make_session_id(self, request):
    method finish_request (line 608) | def finish_request(self, request, client_address):
  class HttpWorker (line 620) | class HttpWorker(threading.Thread):
    method __init__ (line 621) | def __init__(self, session, sspec):
    method idle_tick (line 628) | def idle_tick(self, httpd):
    method run (line 631) | def run(self):
    method quit (line 645) | def quit(self, join=False):

FILE: mailpile/i18n.py
  function _fmt_safe (line 19) | def _fmt_safe(translation, original):
  function gettext (line 40) | def gettext(string):
  function ngettext (line 61) | def ngettext(string1, string2, n):
  class i18n_disabler (line 84) | class i18n_disabler:
    method __init__ (line 85) | def __init__(self):
    method __enter__ (line 88) | def __enter__(self):
    method __exit__ (line 93) | def __exit__(self, *args, **kwargs):
  function ActivateTranslation (line 101) | def ActivateTranslation(session, config, language, localedir=None):
  function ListTranslations (line 151) | def ListTranslations(config, localedir=None):

FILE: mailpile/index/base.py
  class BaseIndex (line 19) | class BaseIndex(MessageInfoConstants):
    method __init__ (line 32) | def __init__(self, config):
    method add_email (line 42) | def add_email(self, email, name=None, eid=None):
    method update_email (line 51) | def update_email(self, email, name=None, change_name=True):
    method compact_to_list (line 61) | def compact_to_list(self, msg_to):
    method expand_to_list (line 73) | def expand_to_list(self, msg_info, field=None):
    method remove_tag (line 81) | def remove_tag(self, session, tid, msg_idxs=None):
    method add_tag (line 84) | def add_tag(self, session, tid, msg_idxs=None):
    method apply_filters (line 87) | def apply_filters(self, session, fid, msg_idxs=None):
    method search (line 93) | def search(self, session, terms, context=None):
    method sort_results (line 96) | def sort_results(self, session, results, sort_order):
    method get_conversation (line 99) | def get_conversation(self, msg_idx=None):
    method get_msg_at_idx_pos_uncached (line 105) | def get_msg_at_idx_pos_uncached(self, msg_idx):
    method open_mailbox_by_ptr (line 108) | def open_mailbox_by_ptr(self, msg_ptr):
    method unique_mbox_ids (line 114) | def unique_mbox_ids(self, msg_info):
    method enumerate_ptrs_mboxes_fds (line 118) | def enumerate_ptrs_mboxes_fds(self, msg_info):
    method _sorted_msg_ptrs (line 132) | def _sorted_msg_ptrs(self, msg_info):
    method _encode_msg_id (line 139) | def _encode_msg_id(self, msg_id):
    method get_msg_id (line 147) | def get_msg_id(self, msg, msg_ptr):
    method _message_to_msg_info (line 150) | def _message_to_msg_info(self, msg_idx_pos, msg_ptr, msg):
    method get_msg_at_idx_pos (line 170) | def get_msg_at_idx_pos(self, msg_idx):
    method set_msg_at_idx_pos (line 191) | def set_msg_at_idx_pos(self, msg_idx, msg_info):
    method get_body (line 197) | def get_body(self, msg_info):
    method truncate_body_snippet (line 215) | def truncate_body_snippet(self, body, max_chars):
    method encode_body (line 222) | def encode_body(self, d, **kwargs):
    method set_body (line 236) | def set_body(self, msg_info, **kwargs):

FILE: mailpile/index/mailboxes.py
  class MailboxIndex (line 15) | class MailboxIndex(BaseIndex):
    method __init__ (line 19) | def __init__(self, config, mailbox, mbx_mid=None):
    method get_msg_at_idx_pos_uncached (line 26) | def get_msg_at_idx_pos_uncached(self, msg_idx_pos):
    method open_mailbox_by_ptr (line 32) | def open_mailbox_by_ptr(self, msg_ptr):
    method _update_keymap (line 38) | def _update_keymap(self):
    method search (line 50) | def search(self, session, terms, context=None):

FILE: mailpile/index/msginfo.py
  class MessageInfoConstants (line 6) | class MessageInfoConstants(object):

FILE: mailpile/index/search.py
  class SearchResultSet (line 8) | class SearchResultSet:
    method __init__ (line 12) | def __init__(self, idx, terms, results, exclude):
    method set_results (line 17) | def set_results(self, results, exclude):
    method __len__ (line 24) | def __len__(self):
    method as_set (line 27) | def as_set(self, order='raw'):
    method excluded (line 30) | def excluded(self):
  class CachedSearchResultSet (line 37) | class CachedSearchResultSet(SearchResultSet):
    method __init__ (line 41) | def __init__(self, idx, terms):
    method _skey (line 48) | def _skey(self):
    method set_results (line 51) | def set_results(self, *args):
    method DropCaches (line 59) | def DropCaches(cls, msg_idxs=None, tags=None):

FILE: mailpile/mail_source/__init__.py
  class BaseMailSource (line 24) | class BaseMailSource(threading.Thread):
    class MailSourceVfs (line 39) | class MailSourceVfs(MailpileVfsBase):
      method __init__ (line 41) | def __init__(self, config, source, *args, **kwargs):
      method _get_mbox_id (line 47) | def _get_mbox_id(self, path):
      method Handles (line 50) | def Handles(self, path):
      method glob_ (line 55) | def glob_(self, *args, **kwargs):
      method listdir_ (line 58) | def listdir_(self, where, **kwargs):
      method open_ (line 61) | def open_(self, fp, *args, **kwargs):
      method abspath_ (line 64) | def abspath_(self, path):
      method isdir_ (line 78) | def isdir_(self, fp):
      method ismailsource_ (line 81) | def ismailsource_(self, fp):
      method mailbox_type_ (line 84) | def mailbox_type_(self, fp, config):
      method getsize_ (line 87) | def getsize_(self, path):
      method display_name_ (line 90) | def display_name_(self, path, config):
      method exists_ (line 100) | def exists_(self, fp):
    method __init__ (line 105) | def __init__(self, session, my_config):
    method __str__ (line 129) | def __str__(self):
    method _pfn (line 135) | def _pfn(self):
    method _load_state (line 138) | def _load_state(self):
    method _save_state (line 164) | def _save_state(self):
    method _save_config (line 167) | def _save_config(self):
    method _log_status (line 171) | def _log_status(self, message, clear_errors=False):
    method open (line 184) | def open(self):
    method close (line 188) | def close(self):
    method _has_mailbox_changed (line 192) | def _has_mailbox_changed(self, mbx, state):
    method _mark_mailbox_rescanned (line 197) | def _mark_mailbox_rescanned(self, mbx, state):
    method _path (line 202) | def _path(self, mbx):
    method _check_interrupt (line 208) | def _check_interrupt(self, log=True, clear=True):
    method _mailbox_sort_key (line 227) | def _mailbox_sort_key(self, m):
    method _sorted_mailboxes (line 230) | def _sorted_mailboxes(self):
    method _policy (line 240) | def _policy(self, mbx_cfg):
    method update_name_to_match_tag (line 246) | def update_name_to_match_tag(self):
    method sync_mail (line 255) | def sync_mail(self):
    method _jitter (line 395) | def _jitter(self, seconds):
    method _sleeping_is_ok (line 398) | def _sleeping_is_ok(self, slept):
    method _sleep (line 401) | def _sleep(self, seconds):
    method _existing_mailboxes (line 421) | def _existing_mailboxes(self):
    method _update_unknown_state (line 427) | def _update_unknown_state(self):
    method reset_event_discovery_state (line 435) | def reset_event_discovery_state(self):
    method set_event_discovery_state (line 440) | def set_event_discovery_state(self, state=None, error=None, status=None):
    method on_event_discovery_starting (line 450) | def on_event_discovery_starting(self):
    method on_event_discovery_toomany (line 457) | def on_event_discovery_toomany(self):
    method on_event_discovery_done (line 470) | def on_event_discovery_done(self, ostate):
    method discover_mailboxes (line 474) | def discover_mailboxes(self, paths=None):
    method _default_policy (line 564) | def _default_policy(self, mbx_cfg):
    method take_over_mailbox (line 567) | def take_over_mailbox(self, mailbox_idx,
    method _guess_tags (line 596) | def _guess_tags(self, mbx_cfg):
    method _strip_file_extension (line 603) | def _strip_file_extension(self, path):
    method _mailbox_path_split (line 606) | def _mailbox_path_split(self, path):
    method _mailbox_name (line 609) | def _mailbox_name(self, path):
    method _create_local_mailbox (line 612) | def _create_local_mailbox(self, mbx_cfg, save=True):
    method _create_parent_tag (line 636) | def _create_parent_tag(self, save=True):
    method _create_primary_tag (line 663) | def _create_primary_tag(self, mbx_cfg, save=True):
    method _path_to_tagname (line 702) | def _path_to_tagname(self, path):  # -> tag name
    method _unique_tag_name (line 713) | def _unique_tag_name(self, tagname):  # -> unused tag name
    method _create_tag_name (line 723) | def _create_tag_name(self, path):  # -> unique tag name
    method _create_tag (line 727) | def _create_tag(self, tag_name_or_id,
    method interrupt_rescan (line 769) | def interrupt_rescan(self, reason):
    method _process_new (line 774) | def _process_new(self, mbx_key, mbx_cfg, mbox,
    method _msg_key_order (line 782) | def _msg_key_order(self, key):
    method _copy_new_messages (line 785) | def _copy_new_messages(self, mbx_key, mbx_cfg, src,
    method rescan_mailbox (line 932) | def rescan_mailbox(self, mbx_key, mbx_cfg, path, stop_after=None):
    method open_mailbox (line 1018) | def open_mailbox(self, mbx_id, fn):
    method is_mailbox (line 1023) | def is_mailbox(self, fn):
    method _summarize_auth (line 1026) | def _summarize_auth(self):
    method run (line 1031) | def run(self):
    method _check_keepalive (line 1121) | def _check_keepalive(self):
    method _log_conn_errors (line 1125) | def _log_conn_errors(self):
    method wake_up (line 1133) | def wake_up(self):
    method notify_config_changed (line 1138) | def notify_config_changed(self):
    method rescan_now (line 1143) | def rescan_now(self, session=None, started_callback=None):
    method quit (line 1176) | def quit(self, join=False):
  function ProcessNew (line 1184) | def ProcessNew(session, msg, msg_metadata_kws, msg_ts, keywords, snippet):
  function MailSource (line 1201) | def MailSource(session, my_config):

FILE: mailpile/mail_source/imap.py
  class IMAP_IOError (line 97) | class IMAP_IOError(IOError):
  class WithaBool (line 101) | class WithaBool(object):
    method __init__ (line 102) | def __init__(self, v): self.v = v
    method __nonzero__ (line 103) | def __nonzero__(self): return self.v
    method __enter__ (line 104) | def __enter__(self, *a, **kw): return self.v
    method __exit__ (line 105) | def __exit__(self, *a, **kw): return self.v
  function _parse_imap (line 108) | def _parse_imap(reply):
  class ImapMailboxIndex (line 148) | class ImapMailboxIndex(MailboxIndex):
  class SharedImapConn (line 152) | class SharedImapConn(threading.Thread):
    method __init__ (line 162) | def __init__(self, session, conn, idle_mailbox=None, idle_callback=None):
    method _mk_proxy (line 182) | def _mk_proxy(self, method):
    method _shutdown (line 228) | def _shutdown(self):
    method close (line 234) | def close(self):
    method select (line 241) | def select(self, mailbox='INBOX', readonly=False):
    method mailbox_info (line 266) | def mailbox_info(self, k, default=None):
    method _update_name (line 271) | def _update_name(self):
    method __enter__ (line 278) | def __enter__(self):
    method __exit__ (line 286) | def __exit__(self, type, value, traceback):
    method _start_idling (line 290) | def _start_idling(self):
    method _stop_idling (line 293) | def _stop_idling(self):
    method _imap_idle (line 296) | def _imap_idle(self):
    method quit (line 336) | def quit(self):
    method run (line 350) | def run(self):
  class SharedImapMailbox (line 377) | class SharedImapMailbox(Mailbox):
    method __init__ (line 387) | def __init__(self, session, mail_source,
    method open_imap (line 399) | def open_imap(self):
    method timed_imap (line 402) | def timed_imap(self, *args, **kwargs):
    method last_updated (line 405) | def last_updated(self):
    method _assert (line 408) | def _assert(self, test, error):
    method __nonzero__ (line 412) | def __nonzero__(self):
    method add (line 423) | def add(self, message):
    method remove (line 432) | def remove(self, key):
    method mailbox_info (line 443) | def mailbox_info(self, k, default=None):
    method get_info (line 450) | def get_info(self, key):
    method get (line 471) | def get(self, key, _bytes=None):
    method get_message (line 510) | def get_message(self, key):
    method get_bytes (line 514) | def get_bytes(self, key, *args):
    method get_file (line 518) | def get_file(self, key):
    method iterkeys (line 522) | def iterkeys(self):
    method keys (line 533) | def keys(self):
    method update_toc (line 536) | def update_toc(self):
    method get_msg_ptr (line 539) | def get_msg_ptr(self, mboxid, key):
    method get_file_by_ptr (line 542) | def get_file_by_ptr(self, msg_ptr):
    method remove_by_ptr (line 545) | def remove_by_ptr(self, msg_ptr):
    method get_msg_size (line 548) | def get_msg_size(self, key):
    method get_metadata_keywords (line 551) | def get_metadata_keywords(self, key):
    method __contains__ (line 564) | def __contains__(self, key):
    method __len__ (line 571) | def __len__(self):
    method flush (line 578) | def flush(self):
    method close (line 581) | def close(self):
    method lock (line 584) | def lock(self):
    method unlock (line 587) | def unlock(self):
    method save (line 590) | def save(self, *args, **kwargs):
    method get_index (line 594) | def get_index(self, config, mbx_mid=None):
    method __unicode__ (line 599) | def __unicode__(self):
    method describe_msg_by_ptr (line 605) | def describe_msg_by_ptr(self, msg_ptr):
  function _connect_imap (line 612) | def _connect_imap(session, settings, event,
  class ImapMailSource (line 780) | class ImapMailSource(BaseMailSource):
    class MailSourceVfs (line 795) | class MailSourceVfs(BaseMailSource.MailSourceVfs):
      method _imap_path (line 797) | def _imap_path(self, path):
      method _imap (line 802) | def _imap(self, *args, **kwargs):
      method listdir_ (line 805) | def listdir_(self, where, **kwargs):
      method getflags_ (line 824) | def getflags_(self, fp, cfg):
      method abspath_ (line 835) | def abspath_(self, fp):
      method display_name_ (line 838) | def display_name_(self, fp, config):
      method isdir_ (line 841) | def isdir_(self, fp):
      method getsize_ (line 847) | def getsize_(self, path):
    method __init__ (line 851) | def __init__(self, *args, **kwargs):
    method Tester (line 864) | def Tester(cls, conn_cls, *args, **kwargs):
    method timed (line 868) | def timed(self, *args, **kwargs):
    method timed_imap (line 871) | def timed_imap(self, *args, **kwargs):
    method _conn_id (line 874) | def _conn_id(self):
    method close (line 883) | def close(self):
    method open (line 893) | def open(self, conn_cls=None, throw=False):
    method _idle_callback (line 972) | def _idle_callback(self, data):
    method _check_keepalive (line 980) | def _check_keepalive(self):
    method open_mailbox (line 987) | def open_mailbox(self, mbx_id, mfn):
    method _get_mbx_id_and_mfn (line 996) | def _get_mbx_id_and_mfn(self, mbx_cfg):
    method _has_mailbox_changed (line 1000) | def _has_mailbox_changed(self, mbx_cfg, state):
    method _mark_mailbox_rescanned (line 1010) | def _mark_mailbox_rescanned(self, mbx, state):
    method _namespace_info (line 1017) | def _namespace_info(self, path):
    method _default_policy (line 1027) | def _default_policy(self, mbx_cfg):
    method _sorted_mailboxes (line 1034) | def _sorted_mailboxes(self):
    method _msg_key_order (line 1041) | def _msg_key_order(self, key):
    method _strip_file_extension (line 1044) | def _strip_file_extension(self, mbx_path):
    method _decode_path (line 1047) | def _decode_path(self, path):
    method _mailbox_path (line 1053) | def _mailbox_path(self, mbx_path):
    method _mailbox_path_split (line 1057) | def _mailbox_path_split(self, mbx_path):
    method _mailbox_name (line 1062) | def _mailbox_name(self, mbx_path):
    method _fmt_path (line 1067) | def _fmt_path(self, path):
    method _fix_empty_discovery_path_bug (line 1070) | def _fix_empty_discovery_path_bug(self):
    method discover_mailboxes (line 1075) | def discover_mailboxes(self, paths=None):
    method _cache_flags (line 1109) | def _cache_flags(self, path, flags=None):
    method _walk_mailbox_path (line 1115) | def _walk_mailbox_path(self, conn, prefix):
    method quit (line 1151) | def quit(self, *args, **kwargs):
  function TestImapSettings (line 1157) | def TestImapSettings(session, settings, event,
  class _MockImap (line 1172) | class _MockImap(object):
    method __init__ (line 1193) | def __init__(self, *args, **kwargs):
    method __getattr__ (line 1203) | def __getattr__(self, attr):
  class _Mocks (line 1207) | class _Mocks(object):
    class NoDns (line 1217) | class NoDns(_MockImap):
      method __init__ (line 1218) | def __init__(self, *args, **kwargs):
    class BadLogin (line 1221) | class BadLogin(_MockImap):

FILE: mailpile/mail_source/imap_starttls.py
  class IMAP4 (line 10) | class IMAP4(imaplib.IMAP4, object):
    method readline (line 19) | def readline(self):
    method starttls (line 26) | def starttls(self, keyfile = None, certfile = None):

FILE: mailpile/mail_source/imap_utf7.py
  function modified_base64 (line 10) | def modified_base64 (s):
  function doB64 (line 14) | def doB64(_in, r):
  function encoder (line 19) | def encoder(s):
  function modified_unbase64 (line 36) | def modified_unbase64(s):
  function decoder (line 40) | def decoder (s):
  class StreamReader (line 62) | class StreamReader (codecs.StreamReader):
    method decode (line 63) | def decode (self, s, errors='strict'):
  class StreamWriter (line 66) | class StreamWriter (codecs.StreamWriter):
    method decode (line 67) | def decode (self, s, errors='strict'):
  function imap4_utf_7 (line 70) | def imap4_utf_7(name):

FILE: mailpile/mail_source/local.py
  class LocalMailSource (line 10) | class LocalMailSource(BaseMailSource):
    method __init__ (line 17) | def __init__(self, *args, **kwargs):
    method _sleeping_is_ok (line 26) | def _sleeping_is_ok(self, slept):
    method close (line 44) | def close(self):
    method open (line 47) | def open(self):
    method _get_macmaildir_data (line 63) | def _get_macmaildir_data(self, path):
    method _data_paths (line 68) | def _data_paths(self, mbx):
    method _mailbox_sort_key (line 85) | def _mailbox_sort_key(self, mbx):
    method _has_mailbox_changed (line 98) | def _has_mailbox_changed(self, mbx, state):
    method _mark_mailbox_rescanned (line 122) | def _mark_mailbox_rescanned(self, mbx, state):
    method _is_mbox (line 128) | def _is_mbox(self, fn):
    method _is_maildir (line 150) | def _is_maildir(self, fn):
    method _is_macmaildir (line 159) | def _is_macmaildir(self, path):
    method is_mailbox (line 166) | def is_mailbox(self, fn):

FILE: mailpile/mail_source/pop3.py
  function _open_pop3_mailbox (line 19) | def _open_pop3_mailbox(session, event, host, port,
  class POP3_IOError (line 64) | class POP3_IOError(IOError):
  class Pop3MailSource (line 68) | class Pop3MailSource(BaseMailSource):
    method __init__ (line 75) | def __init__(self, *args, **kwargs):
    method close (line 79) | def close(self):
    method _sleep (line 89) | def _sleep(self, *args, **kwargs):
    method open (line 93) | def open(self):
    method _has_mailbox_changed (line 112) | def _has_mailbox_changed(self, mbx, state):
    method _mark_mailbox_rescanned (line 119) | def _mark_mailbox_rescanned(self, mbx, state):
    method _fmt_path (line 125) | def _fmt_path(self):
    method open_mailbox (line 128) | def open_mailbox(self, mbx_id, mfn):
    method discover_mailboxes (line 141) | def discover_mailboxes(self, paths=None):
    method is_mailbox (line 150) | def is_mailbox(self, fn):
    method _mailbox_name (line 153) | def _mailbox_name(self, path):
    method _create_tag (line 156) | def _create_tag(self, *args, **kwargs):
  function TestPop3Settings (line 166) | def TestPop3Settings(session, settings, event):

FILE: mailpile/mailboxes/__init__.py
  class NoSuchMailboxError (line 28) | class NoSuchMailboxError(OSError):
  function register (line 32) | def register(prio, cls):
  function IsMailbox (line 38) | def IsMailbox(fn, config):
  function OpenMailbox (line 50) | def OpenMailbox(fn, config, create=False):
  function UnorderedPicklable (line 62) | def UnorderedPicklable(parent, editable=False):

FILE: mailpile/mailboxes/gmvault.py
  class MailpileMailbox (line 12) | class MailpileMailbox(maildir.MailpileMailbox):
    method parse_path (line 16) | def parse_path(cls, config, fn, create=False, allow_empty=False):
    method __init__ (line 24) | def __init__(self, dirname, factory=rfc822.Message, create=True):
    method get_file (line 29) | def get_file(self, key):
    method _refresh (line 38) | def _refresh(self):

FILE: mailpile/mailboxes/macmail.py
  class _MacMaildirPartialFile (line 15) | class _MacMaildirPartialFile(mailbox._PartialFile):
    method __init__ (line 16) | def __init__(self, fd):
  class MacMaildirMessage (line 23) | class MacMaildirMessage(mailbox.Message):
    method __init__ (line 24) | def __init__(self, message=None):
  class MacMaildir (line 32) | class MacMaildir(mailbox.Mailbox):
    method __init__ (line 33) | def __init__(self, dirname, factory=rfc822.Message, create=True):
    method remove (line 67) | def remove(self, key):
    method discard (line 75) | def discard(self, key):
    method __setitem__ (line 85) | def __setitem__(self, key, message):
    method iterkeys (line 89) | def iterkeys(self):
    method has_key (line 98) | def has_key(self, key):
    method __len__ (line 102) | def __len__(self):
    method _refresh (line 106) | def _refresh(self):
    method _lookup (line 123) | def _lookup(self, key):
    method get_message (line 135) | def get_message(self, key):
    method get_file (line 141) | def get_file(self, key):
  class MailpileMailbox (line 146) | class MailpileMailbox(UnorderedPicklable(MacMaildir)):
    method parse_path (line 149) | def parse_path(cls, config, fn, create=False, allow_empty=False):
    method __unicode__ (line 155) | def __unicode__(self):
    method _describe_msg_by_ptr (line 158) | def _describe_msg_by_ptr(self, msg_ptr):

FILE: mailpile/mailboxes/maildir.py
  class MailpileMailbox (line 11) | class MailpileMailbox(UnorderedPicklable(mailbox.Maildir, editable=True)):
    method parse_path (line 16) | def parse_path(cls, config, fn, create=False, allow_empty=False):
    method _refresh (line 25) | def _refresh(self):
    method __unicode__ (line 32) | def __unicode__(self):
    method _describe_msg_by_ptr (line 35) | def _describe_msg_by_ptr(self, msg_ptr):
    method get_metadata_keywords (line 38) | def get_metadata_keywords(self, toc_id):

FILE: mailpile/mailboxes/maildirwin.py
  class MailpileMailbox (line 8) | class MailpileMailbox(maildir.MailpileMailbox):

FILE: mailpile/mailboxes/mbox.py
  class MboxIndex (line 17) | class MboxIndex(MailboxIndex):
  class MailpileMailbox (line 21) | class MailpileMailbox(mailbox.mbox):
    method parse_path (line 27) | def parse_path(cls, config, fn, create=False, allow_empty=False):
    method __init__ (line 39) | def __init__(self, *args, **kwargs):
    method __enter__ (line 52) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 57) | def __exit__(self, *args, **kwargs):
    method __unicode__ (line 61) | def __unicode__(self):
    method describe_msg_by_ptr (line 64) | def describe_msg_by_ptr(self, msg_ptr):
    method _get_fd (line 71) | def _get_fd(self):
    method __setstate__ (line 74) | def __setstate__(self, dict):
    method __getstate__ (line 95) | def __getstate__(self):
    method last_updated (line 105) | def last_updated(self):
    method keys (line 108) | def keys(self):
    method toc_values (line 112) | def toc_values(self):
    method update_toc (line 116) | def update_toc(self):
    method _generate_toc (line 165) | def _generate_toc(self):
    method __setitem__ (line 168) | def __setitem__(self, *args, **kwargs):
    method __delitem__ (line 172) | def __delitem__(self, *args, **kwargs):
    method save (line 176) | def save(self, session=None, to=None, pickler=None):
    method _locked_flush_without_tempfile (line 186) | def _locked_flush_without_tempfile(self):
    method flush (line 205) | def flush(self, *args, **kwargs):
    method clear (line 220) | def clear(self, *args, **kwargs):
    method get_msg_size (line 224) | def get_msg_size(self, toc_id):
    method get_metadata_keywords (line 235) | def get_metadata_keywords(self, toc_id):
    method set_metadata_keywords (line 239) | def set_metadata_keywords(self, *args, **kwargs):
    method get_index (line 242) | def get_index(self, config, mbx_mid=None):
    method get_msg_cs (line 248) | def get_msg_cs(self, start, cs_size, max_length, chars=4, data=None):
    method get_msg_cs4k (line 265) | def get_msg_cs4k(self, start, max_length, data=None):
    method get_msg_cs80b (line 269) | def get_msg_cs80b(self, start, max_length, data=None):
    method get_msg_ptr (line 273) | def get_msg_ptr(self, mboxid, toc_id, data=None):
    method _parse_ptr (line 284) | def _parse_ptr(self, msg_ptr):
    method _verify_ptr_checksums (line 294) | def _verify_ptr_checksums(self, msg_ptr, start, ignored_fd):
    method _possible_message_locations (line 306) | def _possible_message_locations(self, msg_ptr, max_locations=15):
    method _get_SSLP_by_ptr (line 325) | def _get_SSLP_by_ptr(self, msg_ptr, verifier=None, from_=False):
    method update (line 352) | def update(self, *args, **kwargs):
    method discard (line 357) | def discard(self, *args, **kwargs):
    method remove (line 362) | def remove(self, *args, **kwargs):
    method get_file_by_ptr (line 367) | def get_file_by_ptr(self, msg_ptr, verifier=None, from_=False):
    method remove_by_ptr (line 373) | def remove_by_ptr(self, msg_ptr):
    method get_bytes (line 381) | def get_bytes(self, toc_id, *args, **kwargs):
    method get_file (line 385) | def get_file(self, *args, **kwargs):

FILE: mailpile/mailboxes/pop3.py
  class wrappable_POP3_SSL (line 21) | class wrappable_POP3_SSL(poplib.POP3_SSL):
    method __init__ (line 25) | def __init__(self, host,
  class UnsupportedProtocolError (line 40) | class UnsupportedProtocolError(Exception):
  class POP3Mailbox (line 44) | class POP3Mailbox(Mailbox):
    method __init__ (line 48) | def __init__(self, host,
    method lock (line 68) | def lock(self):
    method unlock (line 71) | def unlock(self):
    method _connect (line 74) | def _connect(self):
    method _refresh (line 118) | def _refresh(self):
    method __setitem__ (line 123) | def __setitem__(self, key, message):
    method _get (line 127) | def _get(self, key, _bytes=None):
    method get_message (line 165) | def get_message(self, key):
    method get_bytes (line 169) | def get_bytes(self, key, *args):
    method get_file (line 173) | def get_file(self, key):
    method get_msg_size (line 177) | def get_msg_size(self, key):
    method remove (line 185) | def remove(self, key):
    method stat (line 195) | def stat(self):
    method iterkeys (line 200) | def iterkeys(self):
    method __contains__ (line 214) | def __contains__(self, key):
    method __len__ (line 218) | def __len__(self):
    method flush (line 222) | def flush(self):
    method close (line 226) | def close(self):
  class MailpileMailbox (line 236) | class MailpileMailbox(UnorderedPicklable(POP3Mailbox)):
    method parse_path (line 240) | def parse_path(cls, config, path, create=False, allow_empty=False):
    method save (line 269) | def save(self, *args, **kwargs):
  class _MockPOP3 (line 280) | class _MockPOP3(object):
    method __init__ (line 341) | def __init__(self, *args, **kwargs):
    method list (line 359) | def list(self, which=None):
    method __getattr__ (line 365) | def __getattr__(self, attr):
  class _MockPOP3_Without_UIDL (line 368) | class _MockPOP3_Without_UIDL(_MockPOP3):

FILE: mailpile/mailboxes/wervd.py
  class MailpileMailbox (line 15) | class MailpileMailbox(UnorderedPicklable(mailbox.Maildir, editable=True)):
    method parse_path (line 30) | def parse_path(cls, config, fn, create=False, allow_empty=False):
    method __init2__ (line 40) | def __init2__(self, *args, **kwargs):
    method __unicode__ (line 43) | def __unicode__(self):
    method _describe_msg_by_ptr (line 46) | def _describe_msg_by_ptr(self, msg_ptr):
    method remove (line 54) | def remove(self, key):
    method _refresh (line 70) | def _refresh(self):
    method _get_fd (line 78) | def _get_fd(self, key):
    method get_message (line 88) | def get_message(self, key):
    method get_string (line 97) | def get_string(self, key):
    method get_file (line 102) | def get_file(self, key):
    method get_metadata_keywords (line 106) | def get_metadata_keywords(self, toc_id):
    method set_metadata_keywords (line 114) | def set_metadata_keywords(self, toc_id, kws):
    method add (line 127) | def add(self, message):
    method _dump_message (line 170) | def _dump_message(self, message, target):
    method __setitem__ (line 179) | def __setitem__(self, key, message):

FILE: mailpile/mailutils/__init__.py
  function FormatMbxId (line 6) | def FormatMbxId(n):
  class NotEditableError (line 14) | class NotEditableError(ValueError):
  class NoFromAddressError (line 18) | class NoFromAddressError(ValueError):
  class NoRecipientError (line 22) | class NoRecipientError(ValueError):
  class InsecureSmtpError (line 26) | class InsecureSmtpError(IOError):
    method __init__ (line 27) | def __init__(self, msg, details=None):
  class NoSuchMailboxError (line 32) | class NoSuchMailboxError(OSError):

FILE: mailpile/mailutils/addresses.py
  class AddressHeaderParser (line 16) | class AddressHeaderParser(list):
    method __init__ (line 149) | def __init__(self,
    method _reset (line 161) | def _reset(self, _raw_data=None, strict=False, _raise=False):
    method parse (line 167) | def parse(self, data):
    method _parse (line 170) | def _parse(self, data, strict=False, _raise=False):
    method unquote (line 200) | def unquote(self, string, charset_order=None):
    method unescape (line 225) | def unescape(self, string):
    method escape (line 229) | def escape(self, strng):
    method quote (line 233) | def quote(self, strng):
    method _tokenize (line 243) | def _tokenize(self, string, munge=False):
    method _clean (line 252) | def _clean(self, token):
    method _group (line 263) | def _group(self, tokens, munge=False):
    method _find_addresses (line 285) | def _find_addresses(self, groups, **fa_kwargs):
    method _find_address (line 289) | def _find_address(self, g, _raise=False, munge=False):
    method addresses_list (line 346) | def addresses_list(self, with_keys=False):
    method normalized_addresses (line 355) | def normalized_addresses(self,
    method normalized (line 377) | def normalized(self, **kwargs):

FILE: mailpile/mailutils/emails.py
  function MakeContentID (line 50) | def MakeContentID():
  function MakeBoundary (line 58) | def MakeBoundary():
  function MakeMessageID (line 62) | def MakeMessageID():
  function MakeMessageDate (line 70) | def MakeMessageDate(ts=None):
  function ClearParseCache (line 82) | def ClearParseCache(cache_id=None, pgpmime=False, full=False):
  function ParseMessage (line 93) | def ParseMessage(fd, cache_id=None, update_cache=False,
  function GetTextPayload (line 151) | def GetTextPayload(part):
  function ExtractEmails (line 168) | def ExtractEmails(string, strip_keys=True):
  function ExtractEmailAndName (line 194) | def ExtractEmailAndName(string):
  function CleanHeaders (line 205) | def CleanHeaders(msg, copy_all=True, tombstones=False):
  function CleanMessage (line 230) | def CleanMessage(config, msg):
  function PrepareMessage (line 242) | def PrepareMessage(config, msg,
  class Email (line 336) | class Email(object):
    method __init__ (line 339) | def __init__(self, idx, msg_idx_pos,
    method msg_mid (line 351) | def msg_mid(self):
    method encoded_hdr (line 355) | def encoded_hdr(self, msg, hdr, value=None):
    method Create (line 384) | def Create(cls, idx, mbox_id, mbx,
    method is_editable (line 498) | def is_editable(self, quick=False):
    method _attachment_aid (line 526) | def _attachment_aid(self, att):
    method get_editing_strings (line 539) | def get_editing_strings(self, tree=None, build_tree=True):
    method get_editing_string (line 592) | def get_editing_string(self, tree=None,
    method _update_att_name (line 612) | def _update_att_name(self, part, filename):
    method _make_attachment (line 621) | def _make_attachment(self, fn, msg, filedata=None):
    method update_from_string (line 652) | def update_from_string(self, session, data, final=False):
    method update_from_msg (line 730) | def update_from_msg(self, session, newmsg):
    method reset_caches (line 762) | def reset_caches(self,
    method update_parse_cache (line 772) | def update_parse_cache(self, newmsg):
    method clear_from_parse_cache (line 781) | def clear_from_parse_cache(self):
    method delete_message (line 786) | def delete_message(self, session, flush=True, keep=0):
    method get_msg_info (line 825) | def get_msg_info(self, field=None, uncached=False):
    method get_mbox_ptr_and_fd (line 833) | def get_mbox_ptr_and_fd(self):
    method get_file (line 841) | def get_file(self):
    method get_msg_size (line 844) | def get_msg_size(self):
    method get_metadata_kws (line 850) | def get_metadata_kws(self):
    method get_cache_id (line 854) | def get_cache_id(self):
    method _get_parsed_msg (line 860) | def _get_parsed_msg(self, pgpmime, update_cache=False):
    method _update_crypto_state (line 874) | def _update_crypto_state(self):
    method get_msg (line 914) | def get_msg(self, pgpmime='default', crypto_state_feedback=True):
    method is_thread (line 937) | def is_thread(self):
    method get (line 941) | def get(self, field, default=''):
    method get_sender (line 952) | def get_sender(self):
    method get_headerprints (line 959) | def get_headerprints(self):
    method get_msg_summary (line 962) | def get_msg_summary(self):
    method _find_attachments (line 977) | def _find_attachments(self, att_id, negative=False):
    method add_attachments (line 1001) | def add_attachments(self, session, filenames, filedata=None):
    method remove_attachments (line 1011) | def remove_attachments(self, session, *att_ids):
    method extract_attachment (line 1034) | def extract_attachment(self, session, att_id, name_fmt=None, mode='get'):
    method get_message_tags (line 1104) | def get_message_tags(self):
    method get_message_tree (line 1108) | def get_message_tree(self, want=None, tree=None, pgpmime='default'):
    method decode_text (line 1279) | def decode_text(self, payload, charset='utf-8', binary=True):
    method decode_payload (line 1298) | def decode_payload(self, part):
    method parse_text_part (line 1302) | def parse_text_part(self, data, charset, crypto, mimetype, count):
    method parse_line_type (line 1349) | def parse_line_type(self, line, block, line_count):
    method evaluate_pgp (line 1428) | def evaluate_pgp(self, tree, check_sigs=True, decrypt=False,
    method _decode_gpg (line 1501) | def _decode_gpg(self, message, decrypted):

FILE: mailpile/mailutils/generator.py
  function _is8bitstring (line 81) | def _is8bitstring(s):
  class Generator (line 90) | class Generator:
    method __init__ (line 100) | def __init__(self, outfp,
    method write (line 123) | def write(self, s):
    method flatten (line 127) | def flatten(self, msg, unixfrom=False, linesep=None):
    method clone (line 150) | def clone(self, fp):
    method _write (line 158) | def _write(self, msg):
    method _dispatch (line 185) | def _dispatch(self, msg):
    method _write_headers (line 205) | def _write_headers(self, msg):
    method _handle_text (line 239) | def _handle_text(self, msg):
    method _handle_multipart (line 252) | def _handle_multipart(self, msg):
    method _handle_multipart_signed (line 310) | def _handle_multipart_signed(self, msg):
    method _handle_message_delivery_status (line 325) | def _handle_message_delivery_status(self, msg):
    method _handle_message (line 346) | def _handle_message(self, msg):
  class DecodedGenerator (line 368) | class DecodedGenerator(Generator):
    method __init__ (line 374) | def __init__(self, outfp,
    method _dispatch (line 403) | def _dispatch(self, msg):
  function _make_boundary (line 429) | def _make_boundary(text=None):

FILE: mailpile/mailutils/header.py
  function decode_header (line 28) | def decode_header(header):

FILE: mailpile/mailutils/headerprint.py
  function HeaderPrintMTADetails (line 35) | def HeaderPrintMTADetails(message):
  function HeaderPrintMUADetails (line 60) | def HeaderPrintMUADetails(message, mta=None):
  function HeaderPrintGenericDetails (line 85) | def HeaderPrintGenericDetails(message, which=MUA_HP_HEADERS):
  function HeaderPrints (line 90) | def HeaderPrints(message):

FILE: mailpile/mailutils/html.py
  function clean_html (line 55) | def clean_html(html):
  function extract_text_from_html (line 63) | def extract_text_from_html(html, url_callback=None):

FILE: mailpile/mailutils/safe.py
  function safe_decode_hdr (line 17) | def safe_decode_hdr(msg=None, name=None, hdr=None, charset=None):
  function safe_parse_date (line 85) | def safe_parse_date(date_hdr):
  function safe_message_ts (line 98) | def safe_message_ts(msg, default=None, msg_mid=None, msg_id=None, sessio...
  function safe_get_msg_id (line 149) | def safe_get_msg_id(msg):

FILE: mailpile/mailutils/vcal.py
  function calendar_parse (line 6) | def calendar_parse(payload):
  class VObject (line 36) | class VObject:
    method __init__ (line 37) | def __init__(self):
    method add_part (line 43) | def add_part(self, key, params, value):
    method find_parts (line 46) | def find_parts(self, key):
    method find_one_part (line 53) | def find_one_part(self, key):
    method find_one_part_value (line 59) | def find_one_part_value(self, key, value=None):
    method get_datetime (line 64) | def get_datetime(self, key):
    method to_raw_json (line 71) | def to_raw_json(self):
    method to_json (line 85) | def to_json(self):
  class VTimeZone (line 88) | class VTimeZone(VObject):
  class VTZStandard (line 91) | class VTZStandard(VObject):
  class VTZDaylight (line 94) | class VTZDaylight(VObject):
  class VAlarm (line 97) | class VAlarm(VObject):
  class VEvent (line 100) | class VEvent(VObject):
    method __init__ (line 101) | def __init__(self):
    method to_json (line 104) | def to_json(self):
  class VCalendar (line 128) | class VCalendar(VObject):
    method __init__ (line 129) | def __init__(self):
    method print_events (line 132) | def print_events(self):
    method to_json (line 140) | def to_json(self):

FILE: mailpile/packing.py
  function PackIntSet (line 9) | def PackIntSet(ints):
  function UnpackIntSet (line 41) | def UnpackIntSet(data):
  function PackLongList (line 51) | def PackLongList(longs):
  function UnpackLongList (line 85) | def UnpackLongList(data):
  class StorageBackedData (line 94) | class StorageBackedData(object):
    method __init__ (line 106) | def __init__(self, storage, skey):
    method _pack (line 115) | def _pack(self, data): raise NotImplemented()
    method _unpack (line 116) | def _unpack(self, data): raise NotImplemented()
    method load (line 118) | def load(self):
    method save (line 124) | def save(self, maybe=False):
    method _dirty_maybe_save (line 129) | def _dirty_maybe_save(self):
    method _r (line 136) | def _r(self, method, *args, **kwargs):
    method _w (line 139) | def _w(self, method, *args, **kwargs):
    method _iw (line 144) | def _iw(self, method, *args, **kwargs):
    method __and__ (line 149) | def __and__(s, *a, **kw): return s._r('__and__', *a, **kw)
    method __cmp__ (line 150) | def __cmp__(s, *a, **kw): return s._r('__cmp__', *a, **kw)
    method __contains__ (line 151) | def __contains__(s, *a, **kw): return s._r('__contains__', *a, **kw)
    method __eq__ (line 152) | def __eq__(s, *a, **kw): return s._r('__eq__', *a, **kw)
    method __ge__ (line 153) | def __ge__(s, *a, **kw): return s._r('__ge__', *a, **kw)
    method __getitem__ (line 154) | def __getitem__(s, *a, **kw): return s._r('__getitem__', *a, **kw)
    method __getslice__ (line 155) | def __getslice__(s, *a, **kw): return s._r('__getslice__', *a, **kw)
    method __gt__ (line 156) | def __gt__(s, *a, **kw): return s._r('__gt__', *a, **kw)
    method __iter__ (line 157) | def __iter__(s, *a, **kw): return s._r('__iter__', *a, **kw)
    method __le__ (line 158) | def __le__(s, *a, **kw): return s._r('__le__', *a, **kw)
    method __len__ (line 159) | def __len__(s, *a, **kw): return s._r('__len__', *a, **kw)
    method __lt__ (line 160) | def __lt__(s, *a, **kw): return s._r('__lt__', *a, **kw)
    method __mul__ (line 161) | def __mul__(s, *a, **kw): return s._r('__mul__', *a, **kw)
    method __ne__ (line 162) | def __ne__(s, *a, **kw): return s._r('__ne__', *a, **kw)
    method __or__ (line 163) | def __or__(s, *a, **kw): return s._r('__or__', *a, **kw)
    method __rand__ (line 164) | def __rand__(s, *a, **kw): return s._r('__rand__', *a, **kw)
    method __reduce__ (line 165) | def __reduce__(s, *a, **kw): return s._r('__reduce__', *a, **kw)
    method __repr__ (line 166) | def __repr__(s, *a, **kw): return s._r('__repr__', *a, **kw)
    method __reversed__ (line 167) | def __reversed__(s, *a, **kw): return s._r('__reversed__', *a, **kw)
    method __rmul__ (line 168) | def __rmul__(s, *a, **kw): return s._r('__rmul__', *a, **kw)
    method __rsub__ (line 169) | def __rsub__(s, *a, **kw): return s._r('__rsub__', *a, **kw)
    method __rxor__ (line 170) | def __rxor__(s, *a, **kw): return s._r('__rxor__', *a, **kw)
    method __sizeof__ (line 171) | def __sizeof__(s, *a, **kw): return s._r('__sizeof__', *a, **kw)
    method __sub__ (line 172) | def __sub__(s, *a, **kw): return s._r('__sub__', *a, **kw)
    method __xor__ (line 173) | def __xor__(s, *a, **kw): return s._r('__xor__', *a, **kw)
    method copy (line 174) | def copy(s, *a, **kw): return s._r('copy', *a, **kw)
    method count (line 175) | def count(s, *a, **kw): return s._r('count', *a, **kw)
    method difference (line 176) | def difference(s, *a, **kw): return s._r('difference', *a, **kw)
    method index (line 177) | def index(s, *a, **kw): return s._r('index', *a, **kw)
    method intersection (line 178) | def intersection(s, *a, **kw): return s._r('intersection', *a, **kw)
    method isdisjoint (line 179) | def isdisjoint(s, *a, **kw): return s._r('isdisjoint', *a, **kw)
    method issubset (line 180) | def issubset(s, *a, **kw): return s._r('issubset', *a, **kw)
    method issuperset (line 181) | def issuperset(s, *a, **kw): return s._r('issuperset', *a, **kw)
    method union (line 182) | def union(s, *a, **kw): return s._r('union', *a, **kw)
    method symmetric_difference (line 184) | def symmetric_difference(s, *a, **kw):
    method __iadd__ (line 187) | def __iadd__(s, *a, **kw): return s._iw('__iadd__', *a, **kw)
    method __iand__ (line 188) | def __iand__(s, *a, **kw): return s._iw('__iand__', *a, **kw)
    method __imul__ (line 189) | def __imul__(s, *a, **kw): return s._iw('__imul__', *a, **kw)
    method __ior__ (line 190) | def __ior__(s, *a, **kw): return s._iw('__ior__', *a, **kw)
    method __isub__ (line 191) | def __isub__(s, *a, **kw): return s._iw('__isub__', *a, **kw)
    method __ixor__ (line 192) | def __ixor__(s, *a, **kw): return s._iw('__ixor__', *a, **kw)
    method __delitem__ (line 194) | def __delitem__(s, *a, **kw): return s._w('__delitem__', *a, **kw)
    method __delslice__ (line 195) | def __delslice__(s, *a, **kw): return s._w('__delslice__', *a, **kw)
    method __setitem__ (line 196) | def __setitem__(s, *a, **kw): return s._w('__setitem__', *a, **kw)
    method __setslice__ (line 197) | def __setslice__(s, *a, **kw): return s._w('__setslice__', *a, **kw)
    method add (line 198) | def add(s, *a, **kw): return s._w('add', *a, **kw)
    method append (line 199) | def append(s, *a, **kw): return s._w('append', *a, **kw)
    method clear (line 200) | def clear(s, *a, **kw): return s._w('clear', *a, **kw)
    method discard (line 201) | def discard(s, *a, **kw): return s._w('discard', *a, **kw)
    method extend (line 202) | def extend(s, *a, **kw): return s._w('extend', *a, **kw)
    method insert (line 203) | def insert(s, *a, **kw): return s._w('insert', *a, **kw)
    method pop (line 204) | def pop(s, *a, **kw): return s._w('pop', *a, **kw)
    method remove (line 205) | def remove(s, *a, **kw): return s._w('remove', *a, **kw)
    method reverse (line 206) | def reverse(s, *a, **kw): return s._w('reverse', *a, **kw)
    method sort (line 207) | def sort(s, *a, **kw): return s._w('sort', *a, **kw)
    method update (line 208) | def update(s, *a, **kw): return s._w('update', *a, **kw)
    method difference_update (line 210) | def difference_update(s, *a, **kw):
    method intersection_update (line 212) | def intersection_update(s, *a, **kw):
    method symmetric_difference_update (line 214) | def symmetric_difference_update(s, *a, **kw):
  class StorageBackedSet (line 218) | class StorageBackedSet(StorageBackedData):
    method _pack (line 233) | def _pack(self, data): return PackIntSet(data)
    method _unpack (line 234) | def _unpack(self, data): return UnpackIntSet(data)
  class StorageBackedLongs (line 237) | class StorageBackedLongs(StorageBackedData):
    method _pack (line 252) | def _pack(self, data): return PackLongList(data)
    method _unpack (line 253) | def _unpack(self, data): return UnpackLongList(data)

FILE: mailpile/platforms.py
  function _assert_file_exists (line 27) | def _assert_file_exists(path):
  function DetectBinaries (line 33) | def DetectBinaries(
  function GetDefaultGnuPGCommand (line 104) | def GetDefaultGnuPGCommand(_raise=OSError):
  function GetDefaultOpenSSLCommand (line 108) | def GetDefaultOpenSSLCommand(_raise=OSError):
  function GetDefaultTorPath (line 112) | def GetDefaultTorPath(_raise=OSError):
  function InDesktopEnvironment (line 116) | def InDesktopEnvironment():
  function RenameCannotOverwrite (line 124) | def RenameCannotOverwrite():
  function NeedExplicitPortCheck (line 131) | def NeedExplicitPortCheck():
  function TerminalSupportsAnsiColors (line 138) | def TerminalSupportsAnsiColors():
  function WindowsPopenSemantics (line 145) | def WindowsPopenSemantics():
  function GetAppDataDirectory (line 152) | def GetAppDataDirectory():
  function RestrictReadAccess (line 164) | def RestrictReadAccess(path):
  function RandomListeningPort (line 175) | def RandomListeningPort(count=1, host='127.0.0.1'):

FILE: mailpile/plugins/__init__.py
  class EmailTransform (line 36) | class EmailTransform(object):
    method __init__ (line 38) | def __init__(self, config):
    method _get_sender_profile (line 41) | def _get_sender_profile(self, sender, kwargs):
    method _get_first_part (line 47) | def _get_first_part(self, msg, mimetype):
    method TransformIncoming (line 55) | def TransformIncoming(self, *args, **kwargs):
    method TransformOutgoing (line 58) | def TransformOutgoing(self, *args, **kwargs):
  class PluginError (line 62) | class PluginError(Exception):
  class PluginManager (line 66) | class PluginManager(object):
    method __init__ (line 95) | def __init__(self, plugin_name=None, builtin=False, deprecated=False,
    method _listdir (line 113) | def _listdir(self, path):
    method _uncomment (line 119) | def _uncomment(self, json_data):
    method discover (line 123) | def discover(self, paths, update=False):
    method available (line 155) | def available(self):
    method loadable (line 158) | def loadable(self):
    method loadable_early (line 161) | def loadable_early(self):
    method _import (line 165) | def _import(self, full_name, full_path):
    method _load (line 183) | def _load(self, plugin_name, process_manifest=False, config=None):
    method load (line 241) | def load(self, *args, **kwargs):
    method process_shutdown_hooks (line 248) | def process_shutdown_hooks(self):
    method process_manifests (line 263) | def process_manifests(self):
    method _mf_path (line 278) | def _mf_path(self, mf, *path):
    method _mf_iteritems (line 283) | def _mf_iteritems(self, mf, *path):
    method _get_method (line 286) | def _get_method(self, full_name, method):
    method _get_class (line 293) | def _get_class(self, full_name, class_name):
    method _process_manifest_pass_one (line 299) | def _process_manifest_pass_one(self, full_name,
    method _process_manifest_pass_two (line 345) | def _process_manifest_pass_two(self, full_name,
    method _process_startup_hooks (line 473) | def _process_startup_hooks(self, package,
    method _compat_check (line 484) | def _compat_check(self, strict=True):
    method _rhtf (line 498) | def _rhtf(self, kw_hash, term, function):
    method register_config_variables (line 506) | def register_config_variables(self, *args):
    method register_config_section (line 520) | def register_config_section(self, *args):
    method _txf_in (line 542) | def _txf_in(self, transforms, config, msg, kwargs):
    method _txf_out (line 553) | def _txf_out(self, transforms, cfg, s, r, msg, kwa):
    method incoming_email_crypto_transform (line 564) | def incoming_email_crypto_transform(self, cfg, msg, **kwa):
    method incoming_email_content_transform (line 567) | def incoming_email_content_transform(self, config, msg, **kwa):
    method outgoing_email_content_transform (line 570) | def outgoing_email_content_transform(self, cfg, s, r, m, **kwa):
    method outgoing_email_crypto_transform (line 573) | def outgoing_email_crypto_transform(self, cfg, s, r, m, **kwa):
    method register_incoming_email_crypto_transform (line 576) | def register_incoming_email_crypto_transform(self, name, transform):
    method register_incoming_email_content_transform (line 579) | def register_incoming_email_content_transform(self, name, transform):
    method register_outgoing_email_content_transform (line 582) | def register_outgoing_email_content_transform(self, name, transform):
    method register_outgoing_email_crypto_transform (line 585) | def register_outgoing_email_crypto_transform(self, name, transform):
    method register_data_kw_extractor (line 595) | def register_data_kw_extractor(self, term, function):
    method register_text_kw_extractor (line 599) | def register_text_kw_extractor(self, term, function):
    method register_meta_kw_extractor (line 603) | def register_meta_kw_extractor(self, term, function):
    method get_data_kw_extractors (line 607) | def get_data_kw_extractors(self):
    method get_text_kw_extractors (line 611) | def get_text_kw_extractors(self):
    method get_meta_kw_extractors (line 615) | def get_meta_kw_extractors(self):
    method get_search_term (line 624) | def get_search_term(self, term, default=None):
    method register_search_term (line 628) | def register_search_term(self, term, function):
    method get_filter_hooks (line 640) | def get_filter_hooks(self, hooks):
    method register_filter_hook_pre (line 648) | def register_filter_hook_pre(self, name, hook):
    method register_filter_hook_post (line 652) | def register_filter_hook_post(self, name, hook):
    method _reg_vcard_plugin (line 663) | def _reg_vcard_plugin(self, what, cfg_sect, plugin_classes, cls, dct):
    method register_vcard_importers (line 686) | def register_vcard_importers(self, *importers):
    method register_contact_exporters (line 692) | def register_contact_exporters(self, *exporters):
    method register_contact_context_providers (line 698) | def register_contact_context_providers(self, *providers):
    method register_fast_periodic_job (line 710) | def register_fast_periodic_job(self, name, period, callback):
    method register_slow_periodic_job (line 715) | def register_slow_periodic_job(self, name, period, callback):
    method register_worker (line 725) | def register_worker(self, thread_obj):
    method register_commands (line 735) | def register_commands(self, *args):
    method register_js (line 749) | def register_js(self, plugin, classname, filename):
    method register_css (line 752) | def register_css(self, plugin, classname, filename):
    method register_web_asset (line 755) | def register_web_asset(self, plugin, path, filename, mimetype='text/ht...
    method get_js_classes (line 760) | def get_js_classes(self):
    method get_css_files (line 763) | def get_css_files(self):
    method get_web_asset (line 766) | def get_web_asset(self, path, default=None):
    method register_ui_element (line 783) | def register_ui_element(self, ui_type,
    method get_ui_elements (line 807) | def get_ui_elements(self, ui_type, context):

FILE: mailpile/plugins/autotag.py
  function at_identify (line 45) | def at_identify(at_config):
  function autotag_configs (line 51) | def autotag_configs(config):
  class AutoTagger (line 74) | class AutoTagger(object):
    method __init__ (line 75) | def __init__(self, tagger, trainer):
    method reset (line 80) | def reset(self, at_config):
    method learn (line 85) | def learn(self, *args):
    method should_tag (line 89) | def should_tag(self, *args):
  function SaveAutoTagger (line 93) | def SaveAutoTagger(config, at_config):
  function LoadAutoTagger (line 100) | def LoadAutoTagger(config, at_config):
  class AutoTagCommand (line 127) | class AutoTagCommand(object):
    method __init__ (line 128) | def __init__(self, command):
    method _get_keywords (line 158) | def _get_keywords(self, e):
  class Tagger (line 132) | class Tagger(AutoTagCommand):
    method should_tag (line 133) | def should_tag(self, atagger, at_config, msg, keywords):
  class Trainer (line 138) | class Trainer(AutoTagCommand):
    method learn (line 139) | def learn(self, atagger, at_config, msg, keywords, should_tag):
    method reset (line 143) | def reset(self, atagger, at_config):
  class AutoTagCommand (line 155) | class AutoTagCommand(Command):
    method __init__ (line 128) | def __init__(self, command):
    method _get_keywords (line 158) | def _get_keywords(self, e):
  class Retrain (line 175) | class Retrain(AutoTagCommand):
    method command (line 178) | def command(self):
    method _retrain (line 181) | def _retrain(self, tags=None):
    method interval_retrain (line 309) | def interval_retrain(cls, session):
  class Classify (line 332) | class Classify(AutoTagCommand):
    method _classify (line 336) | def _classify(self, emails):
    method command (line 361) | def command(self):
  class AutoTag (line 368) | class AutoTag(Classify):
    method command (line 372) | def command(self):
  function filter_hook (line 409) | def filter_hook(session, msg_mid, msg, keywords, **kwargs):

FILE: mailpile/plugins/autotag_sb.py
  function _classifier (line 14) | def _classifier(autotagger):
  class SpamBayesTagger (line 20) | class SpamBayesTagger(mailpile.plugins.autotag.Trainer):
    method should_tag (line 21) | def should_tag(self, atagger, at_config, msg, keywords):
  class SpamBayesTrainer (line 33) | class SpamBayesTrainer(mailpile.plugins.autotag.Trainer):
    method learn (line 34) | def learn(self, atagger, at_config, msg, keywords, should_tag):
    method reset (line 37) | def reset(self, atagger, at_config):

FILE: mailpile/plugins/backups.py
  function _gzip (line 31) | def _gzip(filename, data):
  function _gunzip (line 39) | def _gunzip(data):
  function _decrypt (line 44) | def _decrypt(data, config):
  class MakeBackup (line 52) | class MakeBackup(Command):
    method SummarizeTags (line 61) | def SummarizeTags(cls, config):
    method MakeBackupArchive (line 92) | def MakeBackupArchive(cls, config, gnupg, what=None):
    method command (line 183) | def command(self):
  class RestoreBackup (line 215) | class RestoreBackup(Command):
    method _restore_PGP_keys (line 232) | def _restore_PGP_keys(self, config, backup_zip, policy):
    method _adjust_paths (line 247) | def _adjust_paths(self, config):
    method command (line 275) | def command(self):

FILE: mailpile/plugins/compose.py
  class EditableSearchResults (line 34) | class EditableSearchResults(SearchResults):
    method __init__ (line 35) | def __init__(self, session, idx, new, sent, **kwargs):
  function AddComposeMethods (line 46) | def AddComposeMethods(cls):
  class CompositionCommand (line 148) | class CompositionCommand(AddComposeMethods(Search)):
    method _new_msgid (line 167) | def _new_msgid(self):
    method _get_email_updates (line 173) | def _get_email_updates(self, idx, create=False, noneok=False, emails=N...
    method _return_search_results (line 248) | def _return_search_results(self, message, emails,
    method _edit_messages (line 268) | def _edit_messages(self, *args, **kwargs):
    method _real_edit_messages (line 274) | def _real_edit_messages(self, emails, new=True, tag=True, ephemeral=Fa...
  class Draft (line 292) | class Draft(AddComposeMethods(View)):
    method _side_effects (line 300) | def _side_effects(self, emails):
  class Compose (line 316) | class Compose(CompositionCommand):
    method _get_canned (line 326) | def _get_canned(cls, idx, cid):
    method CreateMessage (line 335) | def CreateMessage(cls, idx, session, msgid, cid=None, ephemeral=False):
    method command (line 351) | def command(self):
  class RelativeCompose (line 380) | class RelativeCompose(Compose):
    method prefix_subject (line 389) | def prefix_subject(subject, prefix, prefix_regex):
  class Reply (line 399) | class Reply(RelativeCompose):
    method _add_gpg_key (line 412) | def _add_gpg_key(cls, idx, session, addr):
    method _create_from_to_cc (line 423) | def _create_from_to_cc(cls, idx, session, trees):
    method CreateReply (line 481) | def CreateReply(cls, idx, session, refs, msgid,
    method command (line 553) | def command(self):
  class Forward (line 597) | class Forward(RelativeCompose):
    method CreateForward (line 610) | def CreateForward(cls, idx, session, refs, msgid,
    method command (line 658) | def command(self):
  class Attach (line 703) | class Attach(CompositionCommand):
    method command (line 716) | def command(self, emails=None):
  class UnAttach (line 783) | class UnAttach(CompositionCommand):
    method command (line 795) | def command(self, emails=None):
  class Sendit (line 849) | class Sendit(CompositionCommand):
    method command (line 865) | def command(self, emails=None):
  class Update (line 990) | class Update(CompositionCommand):
    method command (line 999) | def command(self, create=True, outbox=False):
  class UpdateAndSendit (line 1047) | class UpdateAndSendit(Update):
    method command (line 1051) | def command(self, create=True, outbox=True):
  class UnThread (line 1055) | class UnThread(CompositionCommand):
    method command (line 1064) | def command(self):
  class EmptyOutbox (line 1095) | class EmptyOutbox(Sendit):
    method sendmail (line 1101) | def sendmail(cls, session):
    method command (line 1104) | def command(self):

FILE: mailpile/plugins/contacts.py
  class VCardCommand (line 28) | class VCardCommand(Command):
    class CommandResult (line 33) | class CommandResult(Command.CommandResult):
      method as_text (line 36) | def as_text(self):
      method _as_text (line 42) | def _as_text(self):
      method _vcards_as_text (line 51) | def _vcards_as_text(self, result):
    method _form_defaults (line 83) | def _form_defaults(self):
    method _make_new_vcard (line 86) | def _make_new_vcard(self, handle, name, note, kind):
    method _valid_vcard_handle (line 99) | def _valid_vcard_handle(self, vc_handle):
    method _pre_delete_vcard (line 102) | def _pre_delete_vcard(self, vcard):
    method _vcard_list (line 105) | def _vcard_list(self, vcards, mode='mpCard', info=None, simplify=False):
  class VCard (line 139) | class VCard(VCardCommand):
    method command (line 145) | def command(self, save=True):
  class AddVCard (line 159) | class AddVCard(VCardCommand):
    method _add_from_messages (line 178) | def _add_from_messages(self, args, add_recipients):
    method _sanity_check (line 195) | def _sanity_check(self, kind, vcard):
    method _before_vcard_create (line 198) | def _before_vcard_create(self, kind, triplets):
    method _after_vcard_create (line 201) | def _after_vcard_create(self, kind, vcard, state):
    method command (line 204) | def command(self, recipients=False, quietly=False, internal=False):
  class RemoveVCard (line 285) | class RemoveVCard(VCardCommand):
    method command (line 297) | def command(self):
  class VCardAddLines (line 318) | class VCardAddLines(VCardCommand):
    method _get_vcard (line 338) | def _get_vcard(self, handle):
    method command (line 341) | def command(self):
  class VCardSet (line 405) | class VCardSet(VCardAddLines):
    method _get_vcard (line 413) | def _get_vcard(self, handle):
  class VCardRemoveLines (line 424) | class VCardRemoveLines(VCardCommand):
    method command (line 437) | def command(self):
  class ListVCards (line 482) | class ListVCards(VCardCommand):
    method _augment_list_info (line 495) | def _augment_list_info(self, info):
    method command (line 498) | def command(self):
  function ContactVCard (line 549) | def ContactVCard(parent):
  class Contact (line 564) | class Contact(ContactVCard(VCard)):
    method command (line 568) | def command(self, save=True):
  class AddContact (line 607) | class AddContact(ContactVCard(AddVCard)):
  class RemoveContact (line 611) | class RemoveContact(ContactVCard(RemoveVCard)):
  class ListContacts (line 615) | class ListContacts(ContactVCard(ListVCards)):
  class ContactSet (line 620) | class ContactSet(ContactVCard(VCardSet)):
  class ContactImport (line 624) | class ContactImport(Command):
    method command (line 631) | def command(self, format, terms=None, **kwargs):
  class ContactImporters (line 667) | class ContactImporters(Command):
    method command (line 673) | def command(self):
  class AddressSearch (line 687) | class AddressSearch(VCardCommand):
    method _boost_rank (line 698) | def _boost_rank(self, boost, term, *matches):
    method _vcard_addresses (line 709) | def _vcard_addresses(self, cfg, terms, ignored_count, deadline):
    method _index_addresses (line 728) | def _index_addresses(self, cfg, terms, vcard_addresses, count, deadline):
    method command (line 797) | def command(self):
  function ProfileVCard (line 831) | def ProfileVCard(parent):
  class Profile (line 1151) | class Profile(ProfileVCard(VCard)):
  class AddProfile (line 1155) | class AddProfile(ProfileVCard(AddVCard)):
    method _form_defaults (line 1166) | def _form_defaults(self):
    method _before_vcard_create (line 1195) | def _before_vcard_create(self, kind, triplets, vcard=None):
    method _update_vcard_from_post (line 1209) | def _update_vcard_from_post(self, vcard, state=None):
    method _after_vcard_create (line 1241) | def _after_vcard_create(self, kind, vcard, state):
  class EditProfile (line 1245) | class EditProfile(AddProfile):
    method _vcard_to_post_vars (line 1251) | def _vcard_to_post_vars(self, vcard):
    method command (line 1319) | def command(self):
  class RemoveProfile (line 1339) | class RemoveProfile(ProfileVCard(RemoveVCard)):
    method _trash_email (line 1350) | def _trash_email(self, vcard):
    method _delete_keys (line 1359) | def _delete_keys(self, vcard):
    method _cleanup_tags (line 1368) | def _cleanup_tags(self, vcard, delete_tags=False):
    method _unique_usernames (line 1378) | def _unique_usernames(self, vcard):
    method _delete_credentials (line 1396) | def _delete_credentials(self, vcard):
    method _delete_routes (line 1407) | def _delete_routes(self, vcard):
    method _delete_sources (line 1416) | def _delete_sources(self, vcard, delete_tags=False):
    method _trash_email_is_safe (line 1450) | def _trash_email_is_safe(self, vcard):
    method command (line 1458) | def command(self, *args, **kwargs):
  class ListProfiles (line 1490) | class ListProfiles(ProfileVCard(ListVCards)):
  class ProfileSet (line 1495) | class ProfileSet(ProfileVCard(VCardSet)):
  class ChooseFromAddress (line 1499) | class ChooseFromAddress(Command):
    method command (line 1511) | def command(self):
  class ContentTxf (line 1540) | class ContentTxf(EmailTransform):
    method TransformOutgoing (line 1541) | def TransformOutgoing(self, sender, rcpts, msg, **kwargs):

FILE: mailpile/plugins/core.py
  class Load (line 43) | class Load(Command):
    method command (line 50) | def command(self, reset=True, wait=True, wait_all=False, quiet=False):
  class Rescan (line 64) | class Rescan(Command):
    method _progress (line 76) | def _progress(self, progress):
    method command (line 80) | def command(self, slowly=False, cron=False):
    method _rescan_vcards (line 166) | def _rescan_vcards(self, session, which):
    method _run_rescan_command (line 199) | def _run_rescan_command(self, session, timeout=120):
    method _rescan_mailboxes (line 250) | def _rescan_mailboxes(self, session, which='mailboxes', force=True, de...
  class Optimize (line 353) | class Optimize(Command):
    method command (line 358) | def command(self, slowly=False):
  class DeleteMessages (line 370) | class DeleteMessages(Command):
    method command (line 376) | def command(self, slowly=False):
  class BrowseOrLaunch (line 441) | class BrowseOrLaunch(Command):
    method Browse (line 449) | def Browse(cls, sspec):
    method command (line 462) | def command(self):
  class RunWWW (line 481) | class RunWWW(Command):
    method command (line 487) | def command(self):
  class Cleanup (line 523) | class Cleanup(Command):
    method AddTask (line 532) | def AddTask(cls, task, last=False, first=False):
    method command (line 543) | def command(self):
  class WritePID (line 553) | class WritePID(Command):
    method command (line 560) | def command(self):
  class RenderPage (line 568) | class RenderPage(Command):
    method template_path (line 577) | def template_path(self, ttype, template_id=None, **kwargs):
    method command (line 584) | def command(self):
  class ProgramStatus (line 591) | class ProgramStatus(Command):
    class CommandResult (line 599) | class CommandResult(Command.CommandResult):
      method as_text (line 600) | def as_text(self):
    method command (line 657) | def command(self, args=None):
  class CronStatus (line 737) | class CronStatus(Command):
    class CommandResult (line 744) | class CommandResult(Command.CommandResult):
      method as_text (line 745) | def as_text(self):
    method command (line 769) | def command(self, args=None):
  class HealthCheck (line 797) | class HealthCheck(Command):
    method _create_event (line 807) | def _create_event(self):
    method _mem_check (line 826) | def _mem_check(cls, session, config):
    method _disk_check (line 832) | def _disk_check(cls, session, config):
    method _readonly_check (line 838) | def _readonly_check(cls, session, config):
    method check (line 845) | def check(cls, session, config):
    method command (line 885) | def command(self, args=None):
  class GpgCommand (line 890) | class GpgCommand(Command):
    class CommandResult (line 896) | class CommandResult(Command.CommandResult):
      method as_text (line 897) | def as_text(self):
    method command (line 904) | def command(self, args=None):
  class ListDir (line 939) | class ListDir(Command):
    class CommandResult (line 947) | class CommandResult(Command.CommandResult):
      method as_text (line 948) | def as_text(self):
    method command (line 966) | def command(self, args=None):
  class ChangeDir (line 1047) | class ChangeDir(ListDir):
    method command (line 1055) | def command(self, args=None):
  class CatFile (line 1065) | class CatFile(Command):
    class CommandResult (line 1073) | class CommandResult(Command.CommandResult):
      method as_text (line 1074) | def as_text(self):
    method command (line 1080) | def command(self, args=None):
  class ListLanguages (line 1115) | class ListLanguages(Command):
    method command (line 1123) | def command(self):
  class ConfigSet (line 1130) | class ConfigSet(Command):
    method command (line 1147) | def command(self):
  class ConfigAdd (line 1253) | class ConfigAdd(Command):
    method command (line 1266) | def command(self):
  class ConfigUnset (line 1313) | class ConfigUnset(Command):
    method command (line 1324) | def command(self):
  class ConfigPrint (line 1366) | class ConfigPrint(Command):
    method _maybe_all (line 1384) | def _maybe_all(self, list_all, data, key_types, recurse, sanitize):
    method command (line 1411) | def command(self):
  class ConfigureMailboxes (line 1464) | class ConfigureMailboxes(Command):
    method _truthy (line 1492) | def _truthy(self, var, default='n'):
    method command (line 1495) | def command(self):
  class Output (line 1672) | class Output(Command):
    method etag_data (line 1682) | def etag_data(self):
    method max_age (line 1685) | def max_age(self):
    method get_render_mode (line 1688) | def get_render_mode(self):
    method command (line 1691) | def command(self):
  class Pipe (line 1697) | class Pipe(Command):
    class CommandResult (line 1706) | class CommandResult(Command.CommandResult):
      method as_text (line 1707) | def as_text(self):
    method command (line 1719) | def command(self):
  class Quit (line 1793) | class Quit(Command):
    method command (line 1806) | def command(self):
  class IdleQuit (line 1823) | class IdleQuit(Command):
    method check (line 1829) | def check(self):
    method command (line 1834) | def command(self):
  class TrustingQQQ (line 1844) | class TrustingQQQ(Command):
    method command (line 1849) | def command(self):
  class Abort (line 1858) | class Abort(Command):
    method command (line 1869) | def command(self):
  class Help (line 1880) | class Help(Command):
    class CommandResult (line 1888) | class CommandResult(Command.CommandResult):
      method splash_as_text (line 1890) | def splash_as_text(self):
      method variables_as_text (line 1935) | def variables_as_text(self):
      method commands_as_text (line 1949) | def commands_as_text(self):
      method as_text (line 1991) | def as_text(self):
    method command (line 2001) | def command(self):
    method _starting (line 2056) | def _starting(self):
    method _finishing (line 2059) | def _finishing(self, rv, *args, **kwargs):
  class HelpVars (line 2065) | class HelpVars(Help):
    method command (line 2073) | def command(self):
  class HelpSplash (line 2104) | class HelpSplash(Help):
    method command (line 2110) | def command(self, interactive=True):

FILE: mailpile/plugins/crypto_autocrypt.py
  function save_Autocrypt_DB (line 88) | def save_Autocrypt_DB(config):
  function get_Autocrypt_DB (line 93) | def get_Autocrypt_DB(config):
  class AutocryptRecord (line 103) | class AutocryptRecord(object):
    method __init__ (line 111) | def __init__(self, to,
    method float_ratio (line 130) | def float_ratio(self):
    method update_ratio (line 133) | def update_ratio(self, have_key=True):
    method should_encrypt (line 141) | def should_encrypt(self):
    method as_list (line 147) | def as_list(self):
    method as_dict (line 150) | def as_dict(self):
    method as_text (line 155) | def as_text(self):
    method save_to (line 158) | def save_to(self, db):
    method Load (line 163) | def Load(cls, db, to, _raise=KeyError):
  function autocrypt_process_email (line 173) | def autocrypt_process_email(config, msg, msg_mid, msg_ts, sender_email,
  function autocrypt_recommendation (line 278) | def autocrypt_recommendation(config, email, re_encrypted=False, state_db...
  function autocrypt_policy_checker (line 324) | def autocrypt_policy_checker(session, profile, emails):
  class AutocryptSearch (line 345) | class AutocryptSearch(Command):
    class CommandResult (line 352) | class CommandResult(Command.CommandResult):
      method as_text (line 353) | def as_text(self):
    method command (line 364) | def command(self):
  class AutocryptForget (line 380) | class AutocryptForget(Command):
    method command (line 387) | def command(self):
  class AutocryptParse (line 406) | class AutocryptParse(Command):
    method command (line 412) | def command(self):
  class AutocryptPeers (line 432) | class AutocryptPeers(Command):
    class CommandResult (line 438) | class CommandResult(Command.CommandResult):
      method as_text (line 439) | def as_text(self):
    method command (line 446) | def command(self):
  function autocrypt_meta_kwe (line 455) | def autocrypt_meta_kwe(index, msg_mid, msg, msg_size, msg_ts,
  class AutocryptTxf (line 497) | class AutocryptTxf(EmailTransform):
    method TransformOutgoing (line 504) | def TransformOutgoing(self, sender, rcpts, msg, **kwargs):
  class AutocryptKeyLookupHandler (line 557) | class AutocryptKeyLookupHandler(EmailKeyLookupHandler):
    method __init__ (line 565) | def __init__(self, session, *args, **kwargs):
    method _score (line 568) | def _score(self, key):
    method _db_and_acr (line 571) | def _db_and_acr(self, address):
    method _getkey (line 578) | def _getkey(self, email, keyinfo):
    method _lookup (line 590) | def _lookup(self, address, strict_email_match=False):

FILE: mailpile/plugins/crypto_gnupg.py
  class ContentTxf (line 35) | class ContentTxf(EmailTransform):
    method _wrap_key_in_html (line 36) | def _wrap_key_in_html(self, title, keydata):
    method _wrap_key_in_html_vars (line 44) | def _wrap_key_in_html_vars(self, title, keydata):
    method TransformOutgoing (line 56) | def TransformOutgoing(self, sender, rcpts, msg, **kwargs):
  class CryptoTxf (line 147) | class CryptoTxf(EmailTransform):
    method TransformOutgoing (line 148) | def TransformOutgoing(self, sender, rcpts, msg,
  class GPGKeySearch (line 201) | class GPGKeySearch(Command):
    class CommandResult (line 208) | class CommandResult(Command.CommandResult):
      method as_text (line 209) | def as_text(self):
    method command (line 215) | def command(self):
  class GPGKeyReceive (line 223) | class GPGKeyReceive(Command):
    method command (line 231) | def command(self):
  class GPGKeyImport (line 244) | class GPGKeyImport(Command):
    method command (line 258) | def command(self):
  class GPGKeySign (line 288) | class GPGKeySign(Command):
    method command (line 297) | def command(self):
  class GPGKeyImportFromMail (line 318) | class GPGKeyImportFromMail(Search):
    class CommandResult (line 328) | class CommandResult(Command.CommandResult):
      method __init__ (line 329) | def __init__(self, *args, **kwargs):
      method as_text (line 332) | def as_text(self):
    method command (line 340) | def command(self):
  class GPGKeyList (line 368) | class GPGKeyList(Command):
    method command (line 376) | def command(self):
  class GPGKeyExport (line 390) | class GPGKeyExport(Command):
    class CommandResult (line 400) | class CommandResult(Command.CommandResult):
      method __init__ (line 401) | def __init__(self, *args, **kwargs):
      method as_text (line 404) | def as_text(self):
    method command (line 409) | def command(self):
  class GPGKeyListSecret (line 437) | class GPGKeyListSecret(Command):
    method command (line 444) | def command(self):
  class GPGUsageStatistics (line 456) | class GPGUsageStatistics(Search):
    class CommandResult (line 465) | class CommandResult(Command.CommandResult):
      method __init__ (line 466) | def __init__(self, *args, **kwargs):
      method as_text (line 469) | def as_text(self):
    method command (line 478) | def command(self):
  class GPGCheckKeys (line 511) | class GPGCheckKeys(Search):
    class CommandResult (line 521) | class CommandResult(Command.CommandResult):
      method __init__ (line 522) | def __init__(self, *args, **kwargs):
      method as_text (line 525) | def as_text(self):
    method _fix_gen_key (line 541) | def _fix_gen_key(self, min_bits=2048):
    method _fix_mp_config (line 548) | def _fix_mp_config(self, good_key=None):
    method _fix_revoke_key (line 557) | def _fix_revoke_key(self, fprint, comment=''):
    method _fix_disable_key (line 567) | def _fix_disable_key(self, fprint, comment=''):
    method command (line 574) | def command(self):

FILE: mailpile/plugins/crypto_policy.py
  function register_crypto_policy (line 26) | def register_crypto_policy(name, checker):
  class CryptoPolicyBaseAction (line 34) | class CryptoPolicyBaseAction(Command):
  class UpdateCryptoPolicyForUser (line 39) | class UpdateCryptoPolicyForUser(CryptoPolicyBaseAction):
    method command (line 48) | def command(self):
    method _parse_args (line 66) | def _parse_args(self):
  class CryptoPolicy (line 80) | class CryptoPolicy(CryptoPolicyBaseAction):
    method ShouldAttachKey (line 90) | def ShouldAttachKey(cls, config, vcards=None, emails=None, ttl=90):
    method _vcard_policy (line 135) | def _vcard_policy(self, config, email):
    method _encryption_ratio (line 144) | def _encryption_ratio(self, session, idx, email, minimum=5):
    method crypto_policy (line 160) | def crypto_policy(cls, session, idx, emails, should_encrypt=False):
    method command (line 277) | def command(self):

FILE: mailpile/plugins/cryptostate.py
  function text_kw_extractor (line 13) | def text_kw_extractor(index, msg, ctype, text, **kwargs):
  function meta_kw_extractor (line 21) | def meta_kw_extractor(index, msg_mid, msg, msg_size, msg_ts, **kwargs):
  function search (line 93) | def search(config, idx, term, hits):

FILE: mailpile/plugins/dates.py
  function meta_kw_extractor (line 14) | def meta_kw_extractor(index, msg_mid, msg, msg_size, msg_ts, **kwargs):
  function _adjust (line 30) | def _adjust(d):
  function _mk_date (line 39) | def _mk_date(ts):
  function search (line 54) | def search(config, idx, term, hits):

FILE: mailpile/plugins/eventlog.py
  class Events (line 15) | class Events(Command):
    method command (line 44) | def command(self):
  class Cancel (line 131) | class Cancel(Command):
    method command (line 142) | def command(self):
  class Undo (line 162) | class Undo(Command):
    method command (line 172) | def command(self):
  class Watch (line 194) | class Watch(Command):
    method command (line 201) | def command(self):

FILE: mailpile/plugins/exporters.py
  class ExportMail (line 29) | class ExportMail(Command):
    method export_path (line 35) | def export_path(self, mbox_type):
    method create_mailbox (line 41) | def create_mailbox(self, mbox_type, path):
    method command (line 49) | def command(self, save=True):

FILE: mailpile/plugins/groups.py
  function search (line 14) | def search(config, idx, term, hits):
  function GroupVCard (line 35) | def GroupVCard(parent):
  class Group (line 69) | class Group(GroupVCard(VCard)):
  class AddGroup (line 73) | class AddGroup(GroupVCard(AddVCard)):
  class GroupAddLines (line 77) | class GroupAddLines(GroupVCard(VCardAddLines)):
  class RemoveGroup (line 81) | class RemoveGroup(GroupVCard(RemoveVCard)):
  class ListGroups (line 85) | class ListGroups(GroupVCard(ListVCards)):

FILE: mailpile/plugins/gui.py
  function UpdateGUIState (line 23) | def UpdateGUIState():
  class GuiOMaticConnection (line 28) | class GuiOMaticConnection(threading.Thread):
    method __init__ (line 29) | def __init__(self, config, sock, main=False):
    method _do (line 39) | def _do(self, command, **args):
    method _select_sleep (line 49) | def _select_sleep(self, seconds):
    method _state_startup (line 52) | def _state_startup(self, in_state):
    method _state_need_setup (line 74) | def _state_need_setup(self, in_state):
    method _state_please_log_in (line 90) | def _state_please_log_in(self, in_state):
    method _state_loading_index (line 104) | def _state_loading_index(self, in_state):
    method _state_logged_in (line 113) | def _state_logged_in(self, in_state):
    method _state_shutting_down (line 130) | def _state_shutting_down(self, in_state):
    method _choose_state (line 136) | def _choose_state(self):
    method change_state (line 149) | def change_state(self):
    method new_mail_notifications (line 177) | def new_mail_notifications(self, summarize=False):
    method run (line 246) | def run(self):
  class ConnectToGuiOMatic (line 266) | class ConnectToGuiOMatic(Command):
    method command (line 275) | def command(self):

FILE: mailpile/plugins/html_magic.py
  class JsApi (line 26) | class JsApi(RenderPage):
    method max_age (line 34) | def max_age(self):
    method etag_data (line 42) | def etag_data(self):
    method command (line 53) | def command(self, save=True, auto=False):
  class ProgressiveWebApp (line 115) | class ProgressiveWebApp(RenderPage):
    method command (line 123) | def command(self):
  class HttpProxyGetRequest (line 127) | class HttpProxyGetRequest(Command):
    method command (line 141) | def command(self):

FILE: mailpile/plugins/keylookup/__init__.py
  function register_crypto_key_lookup_handler (line 44) | def register_crypto_key_lookup_handler(handler):
  function _score_validity (line 51) | def _score_validity(validity, local=False):
  function _update_scores (line 66) | def _update_scores(session, key_id, key_info, known_keys_list):
  function _normalize_key (line 127) | def _normalize_key(session, key_info):
  function _mailpile_key_list (line 152) | def _mailpile_key_list(gpgi_key_list):
  function lookup_crypto_keys (line 160) | def lookup_crypto_keys(session, address,
  class KeyLookup (line 289) | class KeyLookup(Command):
    method command (line 301) | def command(self):
  class KeyImport (line 336) | class KeyImport(Command):
    method _get_or_create_vcard (line 349) | def _get_or_create_vcard(self, address):
    method command (line 359) | def command(self):
  class KeyTofu (line 402) | class KeyTofu(Command):
    method _key_can_encrypt (line 411) | def _key_can_encrypt(self, gnupg, fingerprint):
    method _recently_used_crypto (line 415) | def _recently_used_crypto(self, tofu_cfg, idx, email):
    method _key_is_trusted (line 439) | def _key_is_trusted(self, fingerprint, known_keys_list):
    method _seen_enough_signatures (line 445) | def _seen_enough_signatures(self, tofu_cfg, idx, email, keyinfo):
    method command (line 455) | def command(self):
  class LookupHandler (line 615) | class LookupHandler:
    method __init__ (line 624) | def __init__(self, session, known_keys_list):
    method _gnupg (line 628) | def _gnupg(self):
    method _score (line 631) | def _score(self, key):
    method _getkey (line 634) | def _getkey(self, email, key):
    method _gk_succeeded (line 637) | def _gk_succeeded(self, result):
    method _lookup (line 641) | def _lookup(self, address, strict_email_match=False):
    method lookup (line 644) | def lookup(self, address, strict_email_match=False, get=None):
    method key_import (line 677) | def key_import(self, address):
  class KeychainLookupHandler (line 681) | class KeychainLookupHandler(LookupHandler):
    method _score (line 689) | def _score(self, key):
    method _lookup (line 692) | def _lookup(self, address, strict_email_match):
    method _getkey (line 713) | def _getkey(self, email, key):
  class KeyserverLookupHandler (line 725) | class KeyserverLookupHandler(LookupHandler):
    method _score (line 744) | def _score(self, key):
    method _lookup_url (line 747) | def _lookup_url(self, url_base, address):
    method _lookup (line 754) | def _lookup(self, address, strict_email_match=False):
    method _getkey_url (line 806) | def _getkey_url(self, url_base, email, key):
    method _getkey (line 814) | def _getkey(self, email, key):
  class VerifyingKeyserverLookupHandler (line 849) | class VerifyingKeyserverLookupHandler(KeyserverLookupHandler):
    method _lookup_url (line 862) | def _lookup_url(self, url_base, address):
    method _score (line 867) | def _score(self, key):

FILE: mailpile/plugins/keylookup/email_keylookup.py
  function _PRUNE_GLOBAL_KEY_CACHE (line 22) | def _PRUNE_GLOBAL_KEY_CACHE():
  function _might_be_pgp_key (line 30) | def _might_be_pgp_key(filename, mimetype):
  class EmailKeyLookupHandler (line 38) | class EmailKeyLookupHandler(LookupHandler, Search):
    method __init__ (line 47) | def __init__(self, session, *args, **kwargs):
    method _score (line 55) | def _score(self, key):
    method _lookup (line 58) | def _lookup(self, address, strict_email_match=False):
    method _getkey (line 79) | def _getkey(self, email, keyinfo):
    method _get_message_keys (line 86) | def _get_message_keys(self, messageid,
  function get_pgp_key_keywords (line 128) | def get_pgp_key_keywords(data):
  function has_pgpkey_data_kw_extractor (line 144) | def has_pgpkey_data_kw_extractor(index, msg, mimetype, filename, part, l...

FILE: mailpile/plugins/keylookup/wkd.py
  function _zbase_encode (line 30) | def _zbase_encode(data):
  function WebKeyDirectoryURLs (line 53) | def WebKeyDirectoryURLs(address, plusmagic=True):
  class WKDLookupHandler (line 72) | class WKDLookupHandler(LookupHandler):
    method __init__ (line 119) | def __init__(self, *args, **kwargs):
    method _score (line 123) | def _score(self, key):
    method _lookup (line 126) | def _lookup(self, address, strict_email_match=True):
    method _getkey (line 200) | def _getkey(self, email, keyinfo):
  class GetWebKeyDirectoryURLs (line 210) | class GetWebKeyDirectoryURLs(Command):
    method command (line 214) | def command(self):

FILE: mailpile/plugins/migrate.py
  function migrate_routes (line 18) | def migrate_routes(session):
  function migrate_mailboxes (line 60) | def migrate_mailboxes(session):
  function migrate_cleanup (line 153) | def migrate_cleanup(session):
  class Migrate (line 201) | class Migrate(Command):
    method command (line 208) | def command(self, before_setup=True, after_setup=True):

FILE: mailpile/plugins/motd.py
  class MessageOfTheDay (line 48) | class MessageOfTheDay(Command):
    method _disable_updates (line 56) | def _disable_updates(cls, session):
    method update (line 65) | def update(cls, session):
    method _get (line 69) | def _get(self, url):
    class CommandResult (line 84) | class CommandResult(Command.CommandResult):
      method as_text (line 85) | def as_text(self):
    method command (line 98) | def command(self):

FILE: mailpile/plugins/oauth.py
  class OAuth2 (line 44) | class OAuth2(TestableWebbable):
    method RedirectURI (line 78) | def RedirectURI(cls, config, oauth2_cfg, http_host=None):
    method ActivateHardCodedOAuth (line 94) | def ActivateHardCodedOAuth(cls, config):
    method GetOAuthConfig (line 100) | def GetOAuthConfig(cls, config, hostname=None, oname=None):
    method GetOAuthURLVars (line 110) | def GetOAuthURLVars(cls, session, ocfg, username):
    method GetOAuthURL (line 123) | def GetOAuthURL(cls, session, ocfg, username, url_vars=None):
    method XOAuth2Response (line 129) | def XOAuth2Response(cls, username, token_info):
    method GetToken (line 134) | def GetToken(cls, session, oauth2_cfg, code, tok_id=None):
    method GetFreshTokenInfo (line 172) | def GetFreshTokenInfo(cls, session, tok_id):
    method setup_command (line 202) | def setup_command(self, session):

FILE: mailpile/plugins/plugins.py
  class Plugins (line 13) | class Plugins(mailpile.commands.Command):
    method command (line 20) | def command(self):
  class LoadPlugin (line 36) | class LoadPlugin(mailpile.commands.Command):
    method command (line 46) | def command(self):
  class DisablePlugin (line 78) | class DisablePlugin(mailpile.commands.Command):
    method command (line 88) | def command(self):

FILE: mailpile/plugins/search.py
  class SearchResults (line 30) | class SearchResults(dict):
    method _name (line 34) | def _name(self, sender, short=True, full_email=False):
    method _names (line 49) | def _names(self, senders):
    method _compact (line 64) | def _compact(self, namelist, maxlen):
    method _metadata (line 87) | def _metadata(self, msg_info):
    method _msg_addresses (line 182) | def _msg_addresses(self, msg_info=None, addresses=[],
    method _address (line 205) | def _address(self, cid=None, e=None, n=None):
    method _msg_tags (line 213) | def _msg_tags(self, msg_info):
    method _tag (line 218) | def _tag(self, tid, attributes={}):
    method _thread (line 229) | def _thread(self, thread_mid):
    method _prune_msg_tree (line 310) | def _prune_msg_tree(self, tree):
    method _troubleshoot_missing_message (line 319) | def _troubleshoot_missing_message(self, email, tree):
    method _message (line 356) | def _message(self, email):
    method __init__ (line 406) | def __init__(self, session, idx,
    method add_msg_info (line 514) | def add_msg_info(self, mid, msg_info, full_threads=False, idxs=None):
    method add_email (line 541) | def add_email(self, e, idxs=None):
    method __nonzero__ (line 554) | def __nonzero__(self):
    method next_set (line 557) | def next_set(self):
    method previous_set (line 563) | def previous_set(self):
    method _fix_width (line 569) | def _fix_width(self, text, width):
    method as_text (line 582) | def as_text(self):
  class Search (line 686) | class Search(Command):
    class CommandResult (line 707) | class CommandResult(Command.CommandResult):
      method __init__ (line 708) | def __init__(self, *args, **kwargs):
      method _fixup (line 717) | def _fixup(self):
      method as_text (line 723) | def as_text(self):
      method as_html (line 735) | def as_html(self, *args, **kwargs):
      method as_dict (line 739) | def as_dict(self, *args, **kwargs):
    method __init__ (line 743) | def __init__(self, *args, **kwargs):
    method _idx (line 749) | def _idx(self, **kwargs):
    method state_as_query_args (line 752) | def state_as_query_args(self):
    method _starting (line 758) | def _starting(self):
    method _email_view_side_effects (line 836) | def _email_view_side_effects(self, emails):
    method switch_indexes (line 849) | def switch_indexes(self, path):
    method _do_search (line 860) | def _do_search(self, search=None, process_args=False):
    method cache_id (line 986) | def cache_id(self, *args, **kwargs):
    method cache_requirements (line 991) | def cache_requirements(self, result):
    method command (line 1011) | def command(self):
  class Next (line 1029) | class Next(Search):
    method command (line 1036) | def command(self):
  class Previous (line 1048) | class Previous(Search):
    method command (line 1055) | def command(self):
  class Order (line 1067) | class Order(Search):
    method command (line 1074) | def command(self):
  class View (line 1083) | class View(Search):
    class RawResult (line 1092) | class RawResult(dict):
      method _decode (line 1093) | def _decode(self):
      method as_text (line 1102) | def as_text(self, *args, **kwargs):
      method as_html (line 1105) | def as_html(self, *args, **kwargs):
    method _side_effects (line 1108) | def _side_effects(self, emails):
    method state_as_query_args (line 1112) | def state_as_query_args(self):
    method command (line 1115) | def command(self):
  class Extract (line 1172) | class Extract(Command):
    class CommandResult (line 1179) | class CommandResult(Command.CommandResult):
      method __init__ (line 1180) | def __init__(self, *args, **kwargs):
      method _fixup (line 1184) | def _fixup(self):
      method as_html (line 1194) | def as_html(self, *args, **kwargs):
      method as_dict (line 1198) | def as_dict(self, *args, **kwargs):
    method command (line 1202) | def command(self):
  function mailbox_search (line 1252) | def mailbox_search(config, idx, term, hits):

FILE: mailpile/plugins/setup_magic.py
  class SetupMagic (line 44) | class SetupMagic(Command):
    method basic_app_config (line 202) | def basic_app_config(self, session,
    method make_master_key (line 327) | def make_master_key(self):
    method URLGet (line 367) | def URLGet(cls, session, url, data=None):
    method _urlget (line 376) | def _urlget(self, url, data=None):
    method setup_command (line 379) | def setup_command(self, session):
    method command (line 382) | def command(self, *args, **kwargs):
  class TestableWebbable (line 386) | class TestableWebbable(SetupMagic):
    method _advance (line 397) | def _advance(self):
    method _success (line 415) | def _success(self, message, result=True, advance=False):
    method _testing (line 420) | def _testing(self):
    method _testing_yes (line 424) | def _testing_yes(self, method, *args, **kwargs):
    method _testing_data (line 433) | def _testing_data(self, method, tdata, *args, **kwargs):
    method setup_command (line 439) | def setup_command(self, session):
  class SetupGetEmailSettings (line 443) | class SetupGetEmailSettings(TestableWebbable):
    method _progress (line 469) | def _progress(self, message):
    method _log_result (line 481) | def _log_result(self, message):
    method _username (line 488) | def _username(self, val, email):
    method _guess_username (line 493) | def _guess_username(self, email):
    method _source_proto (line 501) | def _source_proto(self, insrv):
    method _route_proto (line 512) | def _route_proto(self, outsrv):
    method _rank (line 523) | def _rank(self, entry):
    method _clean_domain (line 541) | def _clean_domain(self, domain):
    method _get_xml_autoconfig (line 554) | def _get_xml_autoconfig(self, url, domain, email):
    method _get_ispdb (line 608) | def _get_ispdb(self, email, domain):
    method _want_anonymity (line 629) | def _want_anonymity(self):
    method _get_mx1 (line 633) | def _get_mx1(self, domain):
    method _get_domain_autoconfig (line 653) | def _get_domain_autoconfig(self, email, domain, mx1, ssl=True):
    method _guess_service_domains (line 671) | def _guess_service_domains(self, domain,
    method _probe_port (line 717) | def _probe_port(self, host, port, encrypted=False):
    method _guess_settings (line 732) | def _guess_settings(self, email, domain, mx1):
    method _get_email_settings (line 778) | def _get_email_settings(self, email):
    method _test_login_and_proto (line 824) | def _test_login_and_proto(self, email, settings):
    method _probe_account_settings (line 858) | def _probe_account_settings(self, email, results):
    method setup_command (line 954) | def setup_command(self, session):
  class SetupWelcome (line 991) | class SetupWelcome(TestableWebbable):
    method bg_setup_stage_1 (line 998) | def bg_setup_stage_1(self):
    method configure_language (line 1008) | def configure_language(self, session, config, language, save=True):
    method setup_command (line 1020) | def setup_command(self, session):
  class CreatePassword (line 1041) | class CreatePassword(TestableWebbable):
    method find_dictionaries (line 1049) | def find_dictionaries(self):
    method load_dictionary (line 1062) | def load_dictionary(self, dpath, maxlen=6):
    method setup_command (line 1066) | def setup_command(self, session):
  class SetupPassword (line 1103) | class SetupPassword(TestableWebbable):
    method setup_command (line 1114) | def setup_command(self, session):
  class SetupTestRoute (line 1149) | class SetupTestRoute(TestableWebbable):
    method setup_command (line 1160) | def setup_command(self, session):
  class SetupTor (line 1216) | class SetupTor(TestableWebbable):
    method autoconfig (line 1224) | def autoconfig(cls, session):
    method auto_configure_tor (line 1227) | def auto_configure_tor(self, session):
    method _configure_tor (line 1254) | def _configure_tor(self, session, hostport, port_zero=False):
    method setup_command (line 1289) | def setup_command(self, session):
  class Setup (line 1302) | class Setup(SetupWelcome):
    method _CHECKPOINTS (line 1318) | def _CHECKPOINTS(self, config):
    method Next (line 1328) | def Next(cls, config, default, needed_auth=True):
    method cli_setup_command (line 1342) | def cli_setup_command(self, session):
    method setup_command (line 1384) | def setup_command(self, session):

FILE: mailpile/plugins/sizes.py
  function meta_kw_extractor (line 15) | def meta_kw_extractor(index, msg_mid, msg, msg_size, msg_ts, **kwargs):
  function _mk_logsize (line 40) | def _mk_logsize(size, default_unit=0):
  function search (line 59) | def search(config, idx, term, hits):

FILE: mailpile/plugins/smtp_server.py
  class SMTPChannel (line 31) | class SMTPChannel(smtpd.SMTPChannel):
    method __init__ (line 36) | def __init__(self, session, *args, **kwargs):
    method _is_dangerous_address (line 45) | def _is_dangerous_address(self, address):
    method _is_spam_address (line 48) | def _is_spam_address(self, address):
    method push (line 51) | def push(self, msg):
    method _address_ok (line 63) | def _address_ok(self, address):
    method _challenge (line 70) | def _challenge(self):
    method _hashgrey_ok (line 75) | def _hashgrey_ok(self, address):
    method smtp_MAIL (line 100) | def smtp_MAIL(self, arg):
    method smtp_RCPT (line 112) | def smtp_RCPT(self, arg):
    method smtp_DATA (line 129) | def smtp_DATA(self, arg):
    method collect_incoming_data (line 136) | def collect_incoming_data(self, data):
  class SMTPServer (line 145) | class SMTPServer(smtpd.SMTPServer):
    method __init__ (line 146) | def __init__(self, session, localaddr, **kwargs):
    method handle_accept (line 150) | def handle_accept(self):
    method process_message (line 156) | def process_message(self, peer, mailfrom, rcpttos, data):
  class SMTPWorker (line 179) | class SMTPWorker(threading.Thread):
    method __init__ (line 180) | def __init__(self, session):
    method run (line 185) | def run(self):
    method quit (line 193) | def quit(self, join=True):
  class HashCash (line 199) | class HashCash(Command):
    method command (line 206) | def command(self):

FILE: mailpile/plugins/tags.py
  function GetFilters (line 76) | def GetFilters(cfg, filter_on=None, types=FILTER_TYPES[:1]):
  function FilterMove (line 95) | def FilterMove(cfg, filter_id, filter_new_id):
  function FilterDelete (line 110) | def FilterDelete(cfg, *filter_ids):
  function GetTags (line 122) | def GetTags(cfg, tn=None, default=None, **kwargs):
  function GetTag (line 172) | def GetTag(cfg, tn, default=None):
  function GetTagID (line 176) | def GetTagID(cfg, tn):
  function GuessTags (line 181) | def GuessTags(cfg, name):
  function Slugify (line 208) | def Slugify(tag_name, tags=None):
  function GetTagInfo (line 219) | def GetTagInfo(cfg, tn, stats=False, unread=None, exclude=None, subtags=...
  class TagCommand (line 268) | class TagCommand(Command):
    method _reorder_all_tags (line 269) | def _reorder_all_tags(self):
    method finish (line 278) | def finish(self, save=True):
  class Tag (line 284) | class Tag(TagCommand):
    class CommandResult (line 300) | class CommandResult(TagCommand.CommandResult):
      method as_text (line 301) | def as_text(self):
    method _get_ops_and_msgids (line 322) | def _get_ops_and_msgids(self, words):
    method _do_tagging (line 363) | def _do_tagging(self, ops, msg_ids, conversations,
    method Undo (line 455) | def Undo(cls, undo, event):
    method command (line 474) | def command(self, **kwargs):
  class TagLater (line 480) | class TagLater(Tag):
    method command (line 484) | def command(self, **kwargs):
  class TagTemporarily (line 497) | class TagTemporarily(Tag):
    method command (line 501) | def command(self, **kwargs):
  class AddTag (line 509) | class AddTag(TagCommand):
    class CommandResult (line 539) | class CommandResult(TagCommand.CommandResult):
      method as_text (line 540) | def as_text(self):
    method command (line 548) | def command(self, save=True):
  class ListTags (line 605) | class ListTags(TagCommand):
    method cache_requirements (line 613) | def cache_requirements(self, result):
    class CommandResult (line 620) | class CommandResult(TagCommand.CommandResult):
      method as_text (line 621) | def as_text(self):
    method command (line 637) | def command(self, **kwargs):
  class DeleteTag (line 727) | class DeleteTag(TagCommand):
    class CommandResult (line 737) | class CommandResult(TagCommand.CommandResult):
      method as_text (line 738) | def as_text(self):
    method command (line 746) | def command(self):
  class TagAutomation (line 785) | class TagAutomation(Command):
    method _tags (line 792) | def _tags(self, args):
    method _perform_auto_action (line 801) | def _perform_auto_action(self, session, tag, dry_run=False):
    method command (line 818) | def command(self):
    method run_in_background (line 855) | def run_in_background(cls, session):
  class FilterCommand (line 870) | class FilterCommand(Command):
    method finish (line 871) | def finish(self, save=True):
  class Filter (line 876) | class Filter(FilterCommand):
    method _truthy (line 898) | def _truthy(self, var):
    method command (line 901) | def command(self, save=True):
  class DeleteFilter (line 1018) | class DeleteFilter(FilterCommand):
    method command (line 1025) | def command(self):
  class ListFilters (line 1047) | class ListFilters(Command):
    class CommandResult (line 1058) | class CommandResult(Command.CommandResult):
      method as_text (line 1059) | def as_text(self):
    method command (line 1067) | def command(self, want_fid=None):
  class MoveFilter (line 1113) | class MoveFilter(ListFilters):
    method command (line 1120) | def command(self):

FILE: mailpile/plugins/vcard_carddav.py
  class DAVClient (line 19) | class DAVClient:
    method __init__ (line 20) | def __init__(self, host,
    method request (line 43) | def request(self, url, method, headers={}, body=""):
    method options (line 75) | def options(self, url):
  class CardDAV (line 80) | class CardDAV(DAVClient):
    method __init__ (line 81) | def __init__(self, host, url,
    method cd (line 89) | def cd(self, url):
    method _check_capability (line 92) | def _check_capability(self):
    method get_vcard (line 96) | def get_vcard(self, url):
    method put_vcard (line 102) | def put_vcard(self, url, vcard):
    method list_vcards (line 105) | def list_vcards(self):
  class CardDAVImporter (line 114) | class CardDAVImporter(VCardImporter):
    method get_contacts (line 129) | def get_contacts(self):
    method filter_contacts (line 138) | def filter_contacts(self, terms):

FILE: mailpile/plugins/vcard_gnupg.py
  class GnuPGImporter (line 21) | class GnuPGImporter(VCardImporter):
    method get_guid (line 37) | def get_guid(self, vcard):
    method import_vcards (line 40) | def import_vcards(self, session, vcard_store, *args, **kwargs):
    method get_vcards (line 45) | def get_vcards(self,
    method key_is_useless (line 86) | def key_is_useless(cls, key):
    method key_vcl (line 92) | def key_vcl(cls, key_id, key):
    method vcards_one_per_uid (line 103) | def vcards_one_per_uid(cls, keys, vcards, kindhint=None):
    method vcards_per_key (line 129) | def vcards_per_key(cls, keys, vcards):
    method vcards_merged (line 156) | def vcards_merged(cls, keys, vcards):
    method gnupg_keys_as_vcards (line 186) | def gnupg_keys_as_vcards(cls, gnupg,
  class PGPKeysAsVCards (line 217) | class PGPKeysAsVCards(Command):
    class CommandResult (line 228) | class CommandResult(Command.CommandResult):
      method as_text (line 229) | def as_text(self):
    method command (line 236) | def command(self):
  class PGPKeysImportAsVCards (line 255) | class PGPKeysImportAsVCards(Command):
    method command (line 268) | def command(self):

FILE: mailpile/plugins/vcard_gravatar.py
  class GravatarImporter (line 18) | class GravatarImporter(VCardImporter):
    method _want_update (line 46) | def _want_update(self):
    method _get (line 68) | def _get(self, url):
    method check_gravatar (line 74) | def check_gravatar(self, vcard, email):
    method get_vcards (line 113) | def get_vcards(self):

FILE: mailpile/plugins/vcard_libravatar.py
  class LibravatarImporter (line 15) | class LibravatarImporter(VCardImporter):
    method _want_update (line 44) | def _want_update(self):
    method _get (line 67) | def _get(self, url):
    method check_libravatar (line 73) | def check_libravatar(self, vcard, email):
    method get_vcards (line 112) | def get_vcards(self):

FILE: mailpile/plugins/vcard_mork.py
  function hexcmp (line 18) | def hexcmp(x, y):
  class MorkImporter (line 32) | class MorkImporter(VCardImporter):
    class Database (line 47) | class Database:
      method __init__ (line 48) | def __init__(self):
    class Table (line 53) | class Table:
      method __init__ (line 54) | def __init__(self):
    class Row (line 60) | class Row:
      method __init__ (line 61) | def __init__(self):
    class Cell (line 66) | class Cell:
      method __init__ (line 67) | def __init__(self):
    method escapeData (line 71) | def escapeData(self, match):
    method escapeMindy (line 84) | def escapeMindy(self, match):
    method encodeMindyValue (line 96) | def encodeMindyValue(self, value):
    method unescapeMork (line 110) | def unescapeMork(self, match):
    method decodeMorkValue (line 117) | def decodeMorkValue(self, value):
    method addToDict (line 122) | def addToDict(self, dict, cells):
    method getRowIdScope (line 129) | def getRowIdScope(self, rowid, cdict):
    method delRow (line 136) | def delRow(self, db, table, rowid):
    method addRow (line 146) | def addRow(self, db, table, rowid, cells):
    method inputMork (line 179) | def inputMork(self, data):
    method morkToHash (line 310) | def morkToHash(self):
    method load (line 334) | def load(self):
    method get_vcards (line 343) | def get_vcards(self):

FILE: mailpile/plugins/webterminal.py
  class TerminalSessionNew (line 17) | class TerminalSessionNew(Command):
    method command (line 26) | def command(self):
  class TerminalSessionEnd (line 39) | class TerminalSessionEnd(Command):
    method command (line 51) | def command(self):
  class TerminalCommand (line 64) | class TerminalCommand(Command):
    method command (line 79) | def command(self):

FILE: mailpile/postinglist.py
  function PLC_CACHE_FlushAndClean (line 40) | def PLC_CACHE_FlushAndClean(session, min_changes=0, keep=5, runtime=None):
  class PostingListContainer (line 78) | class PostingListContainer(object):
    method Load (line 85) | def Load(cls, session, sig, uncached_cb=None):
    method __init__ (line 104) | def __init__(self, session, sig, fd=None):
    method get (line 116) | def get(self, sig, default=None):
    method add (line 119) | def add(self, *args, **kwargs):
    method remove (line 123) | def remove(self, *args, **kwargs):
    method purge_deleted (line 128) | def purge_deleted(self, deleted_sig, deleted_set):
    method save (line 138) | def save(self, split=True):
    method _splits (line 185) | def _splits(self):
    method _load (line 222) | def _load(self):
    method _unlocked_parse_lines (line 245) | def _unlocked_parse_lines(self, lines):
    method _unlocked_add (line 251) | def _unlocked_add(self, sig, values):
    method _unlocked_remove (line 259) | def _unlocked_remove(self, sig, values):
    method _SaveFile (line 268) | def _SaveFile(cls, config, sig):
    method _GetFilenameAndSig (line 272) | def _GetFilenameAndSig(cls, config, sig):
  class PostingList (line 292) | class PostingList(object):
    method Append (line 298) | def Append(cls, session, word, values, compact=False, sig=None):
    method Optimize (line 303) | def Optimize(cls, session, index, lazy=False, quick=False):
    method __init__ (line 307) | def __init__(self, session, word):
    method hits (line 315) | def hits(self):
    method append (line 318) | def append(self, *eids):
    method remove (line 322) | def remove(self, eids):
    method _WordSig (line 327) | def _WordSig(cls, word, config):
  class OldPostingList (line 336) | class OldPostingList(object):
    method _Optimize (line 345) | def _Optimize(cls, session, idx, force=False):
    method _Append (line 349) | def _Append(cls, session, word, mail_ids, compact=True, sig=None):
    method Lock (line 383) | def Lock(cls, lock, method, *args, **kwargs):
    method Optimize (line 388) | def Optimize(cls, *args, **kwargs):
    method Append (line 392) | def Append(cls, *args, **kwargs):
    method WordSig (line 396) | def WordSig(cls, word, config):
    method SaveFile (line 403) | def SaveFile(cls, session, prefix):
    method GetFile (line 407) | def GetFile(cls, session, sig, mode='r'):
    method __init__ (line 427) | def __init__(self, session, word, sig=None, config=None):
    method _parse_lines (line 437) | def _parse_lines(self, lines):
    method load (line 448) | def load(self):
    method _fmt_file (line 460) | def _fmt_file(self, prefix):
    method _compact (line 472) | def _compact(self, prefix, output):
    method save (line 490) | def save(self, prefix=None, compact=True, mode='wb'):
    method hits (line 519) | def hits(self):
    method append (line 522) | def append(self, eid):
    method remove (line 529) | def remove(self, eids):
  class GlobalPostingList (line 539) | class GlobalPostingList(OldPostingList):
    method _Optimize (line 542) | def _Optimize(cls, session, idx,
    method SaveFile (line 596) | def SaveFile(cls, session, prefix):
    method GetFile (line 600) | def GetFile(cls, session, sig, mode='r'):
    method _Append (line 608) | def _Append(cls, session, word, mail_ids, compact=True):
    method GetMaxMsgIdxPos (line 622) | def GetMaxMsgIdxPos(cls):
    method _unlocked_GetMaxMsgIdxPos (line 627) | def _unlocked_GetMaxMsgIdxPos(cls):
    method UpdateMaxMsgMid (line 639) | def UpdateMaxMsgMid(cls, session, msg_mids):
    method __init__ (line 663) | def __init__(self, *args, **kwargs):
    method _fmt_file (line 668) | def _fmt_file(self, prefix):
    method _compact (line 671) | def _compact(self, prefix, output, **kwargs):
    method load (line 674) | def load(self):
    method _migrate (line 684) | def _migrate(self, sig=None, compact=True):
    method _purge_deleted (line 696) | def _purge_deleted(self, sig, deleted_sig, deleted_set):
    method remove (line 703) | def remove(self, eids):
    method hits (line 707) | def hits(self):
    method plc_keys (line 711) | def plc_keys(self):

FILE: mailpile/safe_popen.py
  function PresetSafePopenArgs (line 44) | def PresetSafePopenArgs(**kwargs):
  class Safe_Pipe (line 56) | class Safe_Pipe(object):
    method __init__ (line 64) | def __init__(self):
    method write (line 69) | def write(self, *args, **kwargs):
    method read (line 72) | def read(self, *args, **kwargs):
    method close (line 75) | def close(self):
  class Safe_Popen (line 80) | class Safe_Popen(Unsafe_Popen):
    method _preset_args (line 81) | def _preset_args(self):
    method __init__ (line 87) | def __init__(self, args, bufsize=0,
    method _SAFE_POPEN_unlock (line 220) | def _SAFE_POPEN_unlock(self):
    method communicate (line 228) | def communicate(self, *args, **kwargs):
    method wait (line 233) | def wait(self, *args, **kwargs):
    method __del__ (line 238) | def __del__(self):
  function MakePopenUnsafe (line 248) | def MakePopenUnsafe():
  function MakePopenSafe (line 252) | def MakePopenSafe():

FILE: mailpile/search.py
  class MailIndex (line 39) | class MailIndex(BaseIndex):
    method __init__ (line 57) | def __init__(self, config):
    method l2m (line 78) | def l2m(self, line):
    method m2l (line 93) | def m2l(self, message):
    method load (line 99) | def load(self, session=None):
    method update_msg_tags (line 226) | def update_msg_tags(self, msg_idx_pos, msg_info):
    method _maybe_encrypt (line 236) | def _maybe_encrypt(self, data):
    method save_changes (line 257) | def save_changes(self, session=None):
    method save (line 315) | def save(self, session=None):
    method update_ptrs_and_msgids (line 361) | def update_ptrs_and_msgids(self, session):
    method _remove_location (line 376) | def _remove_location(self, session, msg_ptr):
    method _update_location (line 387) | def _update_location(self, session, msg_idx_pos, msg_ptr):
    method _extract_date_ts (line 403) | def _extract_date_ts(self, session, msg_mid, msg_id, msg, default):
    method _get_scan_progress (line 412) | def _get_scan_progress(self, mailbox_idx, event=None, reset=False):
    method scan_mailbox (line 437) | def scan_mailbox(self, session, mailbox_idx, mailbox_fn, mailbox_opener,
    method scan_one_message (line 582) | def scan_one_message(self, session, mailbox_idx, mbox, msg_mbox_key,
    method _real_scan_one (line 594) | def _real_scan_one(self, session,
    method edit_msg_info (line 667) | def edit_msg_info(self, msg_info,
    method _extract_header_info (line 714) | def _extract_header_info(self, msg):
    method _extract_info_and_index (line 723) | def _extract_info_and_index(self, session, mailbox_idx,
    method _index_incoming_message (line 751) | def _index_incoming_message(self, session,
    method index_email (line 803) | def index_email(self, session, email):
    method set_conversation_ids (line 846) | def set_conversation_ids(self, msg_mid, msg, subject_threading=True):
    method unthread_message (line 1013) | def unthread_message(self, msg_mid, new_subject=None):
    method add_new_msg (line 1116) | def add_new_msg(self, msg_ptr, msg_id, msg_ts, msg_from,
    method add_new_ghost (line 1152) | def add_new_ghost(self, msg_id, trash=False, subject=None):
    method filter_keywords (line 1168) | def filter_keywords(self, session, msg_mid, msg, keywords, incoming=Tr...
    method apply_filters (line 1194) | def apply_filters(self, session, filter_on, msg_mids=None, msg_idxs=No...
    method _list_header_keywords (line 1208) | def _list_header_keywords(self, hdr, val_lower, body_info):
    method read_message (line 1234) | def read_message(self, session,
    method clean_snippet (line 1513) | def clean_snippet(self, snippet):
    method index_message (line 1521) | def index_message(self, session, msg_mid, msg_id,
    method get_msg_at_idx_pos_uncached (line 1572) | def get_msg_at_idx_pos_uncached(self, msg_idx):
    method delete_msg_at_idx_pos (line 1578) | def delete_msg_at_idx_pos(self, session, msg_idx, keep_msgid=False):
    method update_msg_sorting (line 1620) | def update_msg_sorting(self, msg_idx, msg_info):
    method set_msg_at_idx_pos (line 1624) | def set_msg_at_idx_pos(self, msg_idx, msg_info, original_line=None):
    method get_conversation (line 1654) | def get_conversation(self, msg_info=None, msg_idx=None, ghosts=False):
    method get_replies (line 1679) | def get_replies(self, msg_info=None, msg_idx=None):
    method get_tags (line 1685) | def get_tags(self, msg_info=None, msg_idx=None):
    method add_tag (line 1693) | def add_tag(self, session, tag_id,
    method remove_tag (line 1776) | def remove_tag(self, session, tag_id,
    method search_tag (line 1838) | def search_tag(self, session, term, hits, recursion=0):
    method search (line 1852) | def search(self, session, searchterms,
    method _freshness_sorter (line 2026) | def _freshness_sorter(self, msg_info):
    method _prepare_sorting (line 2042) | def _prepare_sorting(self):
    method sort_results (line 2049) | def sort_results(self, session, results, how):

FILE: mailpile/search_history.py
  class SearchHistory (line 13) | class SearchHistory(object):
    method Load (line 26) | def Load(cls, config, merge=None):
    method __init__ (line 36) | def __init__(self):
    method save (line 40) | def save(self, config):
    method _compress (line 47) | def _compress(self, results, order):
    method _decompress (line 55) | def _decompress(self, compressed_bitmask):
    method add (line 59) | def add(self, terms, results, order):
    method get (line 73) | def get(self, session, fprint):
    method expire (line 84) | def expire(self, ttl=None, compact=None):

FILE: mailpile/security.py
  function GetUserSecret (line 28) | def GetUserSecret(workdir):
  function _lockdown (line 46) | def _lockdown(config):
  function in_disk_lockdown (line 62) | def in_disk_lockdown(config):
  function _lockdown_minimal (line 73) | def _lockdown_minimal(config):
  function _lockdown_config (line 80) | def _lockdown_config(config):
  function _lockdown_quit (line 90) | def _lockdown_quit(config):
  function _lockdown_basic (line 98) | def _lockdown_basic(config):
  function _lockdown_strict (line 103) | def _lockdown_strict(config):
  function forbid_command (line 149) | def forbid_command(command_obj, cc_list=None, config=None):
  function forbid_config_change (line 163) | def forbid_config_change(config, config_key):
  function secure_urlget (line 176) | def secure_urlget(session, url,
  function http_content_security_policy (line 218) | def http_content_security_policy(http_server):
  function make_csrf_token (line 231) | def make_csrf_token(secret, session_id, ts=None):
  function valid_csrf_token (line 241) | def valid_csrf_token(secret, session_id, csrf_token):
  function stretch_with_pbkdf2 (line 268) | def stretch_with_pbkdf2(password, salt, params):
  function stretch_with_scrypt (line 277) | def stretch_with_scrypt(password, salt, params):
  class SecurePassphraseStorage (line 303) | class SecurePassphraseStorage(object):
    method __init__ (line 349) | def __init__(self, passphrase=None, stretched=False):
    method copy (line 359) | def copy(self, src):
    method is_set (line 365) | def is_set(self):
    method stretches (line 368) | def stretches(self, salt, params=None):
    method stretched (line 394) | def stretched(self, salt, params=None):
    method set_passphrase (line 398) | def set_passphrase(self, passphrase):
    method compare (line 406) | def compare(self, passphrase):
    method read_byte_at (line 413) | def read_byte_at(self, offset):
    method get_passphrase (line 418) | def get_passphrase(self):
    method get_reader (line 423) | def get_reader(self):
  function tls_sock_cert_sha256 (line 460) | def tls_sock_cert_sha256(sock=None, cert=None):
  function tls_configure (line 476) | def tls_configure(sock, context, args, kwargs):
  function tls_new_context (line 551) | def tls_new_context():
  function tls_cert_tofu (line 558) | def tls_cert_tofu(wrapped, accept_certs, sname):
  function tls_context_wrap_socket (line 573) | def tls_context_wrap_socket(org_wrap, context, sock, *args, **kwargs):
  function tls_wrap_socket (line 583) | def tls_wrap_socket(org_wrap, sock, *args, **kwargs):
  function evaluate_sender_trust (line 595) | def evaluate_sender_trust(config, email, tree):
  function add_tls_context (line 753) | def add_tls_context(unused_org_wrap, sock, *args, **kwargs):

FILE: mailpile/smtp_client.py
  function sha512_512k (line 24) | def sha512_512k(data):
  function sha512_512kCheck (line 43) | def sha512_512kCheck(challenge, bits, solution):
  function sha512_512kCollide (line 50) | def sha512_512kCollide(challenge, bits, callback1k=None):
  function SMTorP_HashCash (line 70) | def SMTorP_HashCash(rcpt, msg, callback1k=None):
  class SMTP (line 83) | class SMTP(smtplib.SMTP):
  class SMTP_SSL (line 87) | class SMTP_SSL(smtplib.SMTP_SSL):
  class SendMailError (line 93) | class SendMailError(IOError):
    method __init__ (line 94) | def __init__(self, msg, details=None):
  function _RouteTuples (line 99) | def _RouteTuples(session, from_to_msg_ev_tuples, test_route=None):
  function SendMail (line 137) | def SendMail(session, msg_mid, from_to_msg_ev_tuples,

FILE: mailpile/spambayes/Options.py
  function load_options (line 1266) | def load_options():
  function get_pathname_option (line 1331) | def get_pathname_option(section, option):

FILE: mailpile/spambayes/OptionsClass.py
  class TypesWrapper (line 109) | class TypesWrapper(object):
  class Option (line 121) | class Option(object):
    method __init__ (line 122) | def __init__(self, name, nice_name="", default=None,
    method display_name (line 134) | def display_name(self):
    method default (line 137) | def default(self):
    method doc (line 140) | def doc(self):
    method valid_input (line 143) | def valid_input(self):
    method no_restore (line 146) | def no_restore(self):
    method set (line 149) | def set(self, val):
    method get (line 152) | def get(self):
    method multiple_values_allowed (line 155) | def multiple_values_allowed(self):
    method is_valid (line 159) | def is_valid(self, value):
    method is_valid_multiple (line 169) | def is_valid_multiple(self, value):
    method is_valid_single (line 179) | def is_valid_single(self, value):
    method _split_values (line 209) | def _split_values(self, value):
    method as_nice_string (line 232) | def as_nice_string(self, section=None):
    method as_documentation_string (line 247) | def as_documentation_string(self, section=None):
    method write_config (line 267) | def write_config(self, file):
    method convert (line 274) | def convert(self, value):
    method _convert (line 311) | def _convert(self, value, to_type):
    method unconvert (line 324) | def unconvert(self):
    method is_boolean (line 384) | def is_boolean(self):
  class OptionsClass (line 407) | class OptionsClass(object):
    method __init__ (line 408) | def __init__(self):
    method update_file (line 431) | def update_file(self, filename):
    method _add_missing (line 514) | def _add_missing(self, out, written, sect, vi, label=True):
    method load_defaults (line 531) | def load_defaults(self, defaults):
    method set_restore_point (line 550) | def set_restore_point(self):
    method revert_to_restore_point (line 561) | def revert_to_restore_point(self):
    method merge_files (line 572) | def merge_files(self, file_list):
    method convert_and_set (line 576) | def convert_and_set(self, section, option, value):
    method merge_file (line 580) | def merge_file(self, filename):
    method display_name (line 614) | def display_name(self, sect, opt):
    method default (line 617) | def default(self, sect, opt):
    method doc (line 620) | def doc(self, sect, opt):
    method valid_input (line 623) | def valid_input(self, sect, opt):
    method no_restore (line 626) | def no_restore(self, sect, opt):
    method is_valid (line 629) | def is_valid(self, sect, opt, value):
    method multiple_values_allowed (line 632) | def multiple_values_allowed(self, sect, opt):
    method is_boolean (line 636) | def is_boolean(self, sect, opt):
    method convert (line 640) | def convert(self, sect, opt, value):
    method unconvert (line 644) | def unconvert(self, sect, opt):
    method get_option (line 648) | def get_option(self, sect, opt):
    method get (line 654) | def get(self, sect, opt):
    method __getitem__ (line 660) | def __getitem__(self, key):
    method set (line 663) | def set(self, sect, opt, val=None):
    method set_from_cmdline (line 692) | def set_from_cmdline(self, arg, stream=None):
    method _report_deprecated_error (line 710) | def _report_deprecated_error(self, sect, opt):
    method _report_option_error (line 716) | def _report_option_error(self, sect, opt, val, stream, msg):
    method __setitem__ (line 738) | def __setitem__(self, key, value):
    method sections (line 741) | def sections(self):
    method options_in_section (line 750) | def options_in_section(self, section):
    method options (line 759) | def options(self, prepend_section_name=False):
    method display (line 771) | def display(self, add_comments=False):
    method _display_nice (line 794) | def _display_nice(self, section, option, formatter):
    method display_full (line 817) | def display_full(self, section=None, option=None):
    method output_for_docs (line 821) | def output_for_docs(self, section=None, option=None):

FILE: mailpile/spambayes/Tester.py
  class Test (line 3) | class Test:
    method __init__ (line 23) | def __init__(self):
    method set_classifier (line 27) | def set_classifier(self, classifier):
    method reset_test_results (line 30) | def reset_test_results(self):
    method train (line 49) | def train(self, hamstream=None, spamstream=None):
    method untrain (line 61) | def untrain(self, hamstream=None, spamstream=None):
    method predict (line 81) | def predict(self, stream, is_spam, callback=None):
    method false_positive_rate (line 115) | def false_positive_rate(self):
    method false_negative_rate (line 119) | def false_negative_rate(self):
    method unsure_rate (line 123) | def unsure_rate(self):
    method false_positives (line 127) | def false_positives(self):
    method false_negatives (line 130) | def false_negatives(self):
    method unsures (line 133) | def unsures(self):
  class _Example (line 136) | class _Example:
    method __init__ (line 137) | def __init__(self, name, words):
    method __iter__ (line 140) | def __iter__(self):

FILE: mailpile/spambayes/chi2.py
  function chi2Q (line 5) | def chi2Q(x2, v, exp=_math.exp, min=min):
  function normZ (line 23) | def normZ(z, sqrt2pi=_math.sqrt(2.0*_math.pi), exp=_math.exp):
  function normP (line 27) | def normP(z):
  function normIQ (line 59) | def normIQ(p, sqrt=_math.sqrt, ln=_math.log):
  function normIP (line 84) | def normIP(p):
  function main (line 93) | def main():
  function showscore (line 169) | def showscore(ps, ln=_math.log, ln2=_math.log(2), frexp=_math.frexp):

FILE: mailpile/spambayes/classifier.py
  class WordInfo (line 51) | class WordInfo(object):
    method __init__ (line 63) | def __init__(self):
    method __repr__ (line 66) | def __repr__(self):
    method __getstate__ (line 69) | def __getstate__(self):
    method __setstate__ (line 72) | def __setstate__(self, t):
  class Classifier (line 76) | class Classifier:
    method __init__ (line 91) | def __init__(self):
    method __getstate__ (line 96) | def __getstate__(self):
    method __setstate__ (line 99) | def __setstate__(self, t):
    method chi2_spamprob (line 124) | def chi2_spamprob(self, wordstream, evidence=False):
    method learn (line 196) | def learn(self, wordstream, is_spam):
    method unlearn (line 207) | def unlearn(self, wordstream, is_spam):
    method probability (line 216) | def probability(self, record):
    method _add_msg (line 297) | def _add_msg(self, wordstream, is_spam):
    method _remove_msg (line 318) | def _remove_msg(self, wordstream, is_spam):
    method _post_training (line 345) | def _post_training(self):
    method _getclues (line 359) | def _getclues(self, wordstream):
    method _worddistanceget (line 433) | def _worddistanceget(self, word):
    method _wordinfoget (line 442) | def _wordinfoget(self, word):
    method _wordinfoset (line 445) | def _wordinfoset(self, word, record):
    method _wordinfodel (line 448) | def _wordinfodel(self, word):
    method _enhance_wordstream (line 451) | def _enhance_wordstream(self, wordstream):
    method _wordinfokeys (line 479) | def _wordinfokeys(self):

FILE: mailpile/spambayes/safepickle.py
  function pickle_read (line 12) | def pickle_read(filename):
  function pickle_write (line 21) | def pickle_write(filename, value, protocol=0):

FILE: mailpile/tests/__init__.py
  function get_mailpile_root (line 29) | def get_mailpile_root():
  function _initialize_mailpile_for_testing (line 46) | def _initialize_mailpile_for_testing(workdir, test_data):
  function get_shared_mailpile (line 77) | def get_shared_mailpile():
  function capture (line 106) | def capture():
  class MailPileUnittest (line 118) | class MailPileUnittest(unittest.TestCase):
    method __init__ (line 119) | def __init__(self, *args, **kwargs):
    method setUpClass (line 123) | def setUpClass(cls):

FILE: mailpile/tests/data/pgp-data/buildexamples.py
  function getSourceFiles (line 7) | def getSourceFiles():
  function getProcesses (line 10) | def getProcesses():
  function runPGP (line 14) | def runPGP(input, params):
  function genExamples (line 27) | def genExamples():

FILE: mailpile/tests/gui/__init__.py
  class ElementHasClass (line 19) | class ElementHasClass(object):
    method __init__ (line 20) | def __init__(self, locator_tuple, class_name):
    method __call__ (line 24) | def __call__(self, driver):
  class ElementHasNotClass (line 32) | class ElementHasNotClass(object):
    method __init__ (line 33) | def __init__(self, locator_tuple, class_name):
    method __call__ (line 37) | def __call__(self, driver):
  class SeleniumScreenshotOnExceptionAspecter (line 45) | class SeleniumScreenshotOnExceptionAspecter(type):
    method __new__ (line 66) | def __new__(mcs, name, bases, dict):
    method wrap_method (line 77) | def wrap_method(mcs, method):
  class MailpileSeleniumTest (line 108) | class MailpileSeleniumTest(MailPileUnittest):
    method __init__ (line 134) | def __init__(self, *args, **kwargs):
    method setUp (line 137) | def setUp(self):
    method tearDown (line 140) | def tearDown(self):
    method _get_mailpile_sspec (line 148) | def _get_mailpile_sspec(cls):
    method _get_mailpile_url (line 153) | def _get_mailpile_url(cls):
    method _start_web_server (line 157) | def _start_web_server(cls):
    method _start_selenium_driver (line 165) | def _start_selenium_driver(cls):
    method _stop_selenium_driver (line 174) | def _stop_selenium_driver(cls):
    method setUpClass (line 183) | def setUpClass(cls):
    method _stop_web_server (line 190) | def _stop_web_server(cls):
    method tearDownClass (line 198) | def tearDownClass(cls):
    method go_to_mailpile_home (line 204) | def go_to_mailpile_home(self):
    method take_screenshot (line 207) | def take_screenshot(self, filename):
    method dump_source_to (line 213) | def dump_source_to(self, filename):
    method navigate_to (line 217) | def navigate_to(self, name):
    method submit_form (line 223) | def submit_form(self, form_id):
    method fill_form_field (line 227) | def fill_form_field(self, field, text):
    method assert_link_with_text (line 231) | def assert_link_with_text(self, text):
    method click_element_with_link_text (line 237) | def click_element_with_link_text(self, text):
    method click_element_with_id (line 243) | def click_element_with_id(self, element_id):
    method click_element_with_class (line 246) | def click_element_with_class(self, class_name):
    method page_title (line 249) | def page_title(self):
    method find_element_by_id (line 252) | def find_element_by_id(self, id):
    method find_element_containing_text (line 255) | def find_element_containing_text(self, text):
    method find_element_by_xpath (line 258) | def find_element_by_xpath(self, xpath):
    method find_element_by_class_name (line 261) | def find_element_by_class_name(self, class_name):
    method assert_text (line 264) | def assert_text(self, text):
    method wait_until_element_is_visible (line 267) | def wait_until_element_is_visible(self, element_id):
    method wait_until_element_is_visible_by_locator (line 270) | def wait_until_element_is_visible_by_locator(self, locator_tuple):
    method wait_until_element_is_invisible_by_locator (line 274) | def wait_until_element_is_invisible_by_locator(self, locator_tuple):
    method wait_until_element_has_class (line 278) | def wait_until_element_has_class(self, locator_tuple, class_name):
    method wait_until_element_has_not_class (line 281) | def wait_until_element_has_not_class(self, locator_tuple, class_name):
    method wait_for_element_condition (line 284) | def wait_for_element_condition(self, expected_conditions):

FILE: mailpile/tests/gui/test_contacts.py
  class ContactsGuiTest (line 4) | class ContactsGuiTest(MailpileSeleniumTest):
    method test_add_new_contact (line 5) | def test_add_new_contact(self):

FILE: mailpile/tests/gui/test_mail.py
  class MailGuiTest (line 4) | class MailGuiTest(MailpileSeleniumTest):
    method test_read_mail (line 5) | def test_read_mail(self):

FILE: mailpile/tests/gui/test_tags.py
  class TagGuiTest (line 9) | class TagGuiTest(MailpileSeleniumTest):
    method test_mark_read_unread (line 10) | def test_mark_read_unread(self):
    method _click_on_visible_element_with_class_name (line 27) | def _click_on_visible_element_with_class_name(self, class_name):
    method _toggle_tag_bar (line 32) | def _toggle_tag_bar(self):
    method _assert_element_has_class (line 37) | def _assert_element_has_class(self, element_id, class_name):
    method _assert_element_not_class (line 40) | def _assert_element_not_class(self, element_id, class_name):

FILE: mailpile/tests/test_command.py
  class TestCommands (line 10) | class TestCommands(MailPileUnittest):
    method test_index (line 11) | def test_index(self):
    method test_search (line 15) | def test_search(self):
    method test_optimize (line 20) | def test_optimize(self):
    method test_set (line 24) | def test_set(self):
    method test_unset (line 29) | def test_unset(self):
    method test_add (line 34) | def test_add(self):
    method test_add_mailbox_already_in_pile (line 38) | def test_add_mailbox_already_in_pile(self):
    method test_add_mailbox_no_such_directory (line 42) | def test_add_mailbox_no_such_directory(self):
    method test_output (line 46) | def test_output(self):
    method test_help (line 50) | def test_help(self):
    method test_help_variables (line 54) | def test_help_variables(self):
    method test_help_with_param_search (line 58) | def test_help_with_param_search(self):
    method test_help_urlmap_as_text (line 62) | def test_help_urlmap_as_text(self):
    method test_crypto_policy_action (line 67) | def test_crypto_policy_action(self):
    method test_reply_no_subject (line 74) | def test_reply_no_subject(self):
    method test_reply_subjects_on_first_msg (line 83) | def test_reply_subjects_on_first_msg(self):
    method test_reply_subject_on_reply_msg (line 91) | def test_reply_subject_on_reply_msg(self):
    method test_reply_subject_on_fw_msg (line 99) | def test_reply_subject_on_fw_msg(self):
    method test_fwd_subject_on_re_msg (line 107) | def test_fwd_subject_on_re_msg(self):
    method test_fw_subject_on_fw_msg (line 115) | def test_fw_subject_on_fw_msg(self):
  class TestCommandResult (line 124) | class TestCommandResult(MailPileUnittest):
    method test_command_result_as_dict (line 125) | def test_command_result_as_dict(self):
    method test_command_result_as_text (line 129) | def test_command_result_as_text(self):
    method test_command_result_as_text_for_boolean_result (line 133) | def test_command_result_as_text_for_boolean_result(self):
    method test_command_result_non_zero (line 139) | def test_command_result_non_zero(self):
    method test_command_result_as_json (line 143) | def test_command_result_as_json(self):
    method test_command_result_as_html (line 147) | def test_command_result_as_html(self):
  class TestTagging (line 152) | class TestTagging(MailPileUnittest):
    method test_addtag (line 153) | def test_addtag(self):
  class TestGPG (line 157) | class TestGPG(MailPileUnittest):
    method test_key_search (line 158) | def test_key_search(self):
    method test_key_receive (line 177) | def test_key_receive(self):
    method test_key_import (line 194) | def test_key_import(self):
    method test_nicknym_get_key (line 199) | def test_nicknym_get_key(self):
    method test_nicknym_refresh_key (line 202) | def test_nicknym_refresh_key(self):

FILE: mailpile/tests/test_config.py
  class TestConfig (line 10) | class TestConfig(MailPileUnittest):
    method test_BoolCheck_trues (line 15) | def test_BoolCheck_trues(self):
    method test_BoolCheck_falses (line 20) | def test_BoolCheck_falses(self):
    method test_BoolCheck_exception (line 25) | def test_BoolCheck_exception(self):
    method test_RouteProtocolCheck_valid (line 32) | def test_RouteProtocolCheck_valid(self):
    method test_RouteProtocolCheck_invalid (line 43) | def test_RouteProtocolCheck_invalid(self):
    method test_HostNameValid_ipv4 (line 51) | def test_HostNameValid_ipv4(self):
    method test_HostNameValid_ipv6 (line 60) | def test_HostNameValid_ipv6(self):
    method test_HostNameValid_hostname (line 70) | def test_HostNameValid_hostname(self):
    method test_HostNameCheck_valid (line 85) | def test_HostNameCheck_valid(self):
    method test_HostNameCheck_invalid (line 95) | def test_HostNameCheck_invalid(self):
    method test_HostNameCheck_non_socket_errors_still_raised (line 114) | def test_HostNameCheck_non_socket_errors_still_raised(self):
    method test_SlugCheck_valid (line 120) | def test_SlugCheck_valid(self):
    method test_SlugCheck_invalid (line 126) | def test_SlugCheck_invalid(self):
    method test_SlashSlugCheck (line 134) | def test_SlashSlugCheck(self):
    method test_B36Check (line 143) | def test_B36Check(self):
    method test_B36Check (line 149) | def test_B36Check(self):
    method test_PathCheck_valid (line 160) | def test_PathCheck_valid(self):
    method test_PathCheck_invalid (line 171) | def test_PathCheck_invalid(self):
    method test_FileCheck_valid (line 184) | def test_FileCheck_valid(self):
    method test_FileCheck_invalid (line 195) | def test_FileCheck_invalid(self):
    method test_DirCheck_valid (line 208) | def test_DirCheck_valid(self):
    method test_DirCheck_invalid (line 219) | def test_DirCheck_invalid(self):
    method test_NewPathCheck_valid (line 232) | def test_NewPathCheck_valid(self):
    method test_NewPathCheck_invalid (line 244) | def test_NewPathCheck_invalid(self):
    method test_UrlCheck_valid (line 254) | def test_UrlCheck_valid(self):
    method test_UrlCheck_invalid (line 265) | def test_UrlCheck_invalid(self):
    method test_EmailCheck_valid (line 279) | def test_EmailCheck_valid(self):
    method test_EmailCheck_invalid (line 294) | def test_EmailCheck_invalid(self):
    method test_GPGKeyCheck_valid (line 305) | def test_GPGKeyCheck_valid(self):
    method test_GPGKeyCheck_invalid (line 321) | def test_GPGKeyCheck_invalid(self):

FILE: mailpile/tests/test_crypto_policy.py
  class CryptoPolicyBaseTest (line 8) | class CryptoPolicyBaseTest(MailPileUnittest):
    method setUp (line 9) | def setUp(self):
    method _add_vcard (line 13) | def _add_vcard(self, full_name, email):
  class UpdateCryptoPolicyForUserTest (line 20) | class UpdateCryptoPolicyForUserTest(CryptoPolicyBaseTest):
    method test_args_are_checked (line 21) | def test_args_are_checked(self):
    method test_policies_are_validated (line 27) | def test_policies_are_validated(self):
    method test_vcard_has_to_exist (line 42) | def test_vcard_has_to_exist(self):
    method test_vcard_is_updated (line 47) | def test_vcard_is_updated(self):
  class CryptoPolicyForUserTest (line 54) | class CryptoPolicyForUserTest(CryptoPolicyBaseTest):
    method test_no_email_provided (line 55) | def test_no_email_provided(self):
    method test_no_msg_with_email_ (line 59) | def test_no_msg_with_email_(self):
    method test_with_signed_email (line 64) | def test_with_signed_email(self):
    method test_with_encrypted_email (line 69) | def test_with_encrypted_email(self):
    method test_vcard_overrides_mail_history (line 74) | def test_vcard_overrides_mail_history(self):

FILE: mailpile/tests/test_eventlog.py
  class TestEventlog (line 18) | class TestEventlog(MailPileUnittest):
    method setUp (line 20) | def setUp(self):
    method tearDown (line 23) | def tearDown(self):
    method test_NewEventId (line 30) | def test_NewEventId(self):
    method test_ClassName (line 42) | def test_ClassName(self):
    method test_ClassName_unicode (line 50) | def test_ClassName_unicode(self):
    method test_event_Parse (line 71) | def test_event_Parse(self):
    method test_event_Parse_invalid (line 85) | def test_event_Parse_invalid(self):
    method test_event_as_dict (line 89) | def test_event_as_dict(self):
    method test_event_as_dict_no_private (line 102) | def test_event_as_dict_no_private(self):
    method test_event_as_json (line 109) | def test_event_as_json(self):
    method test_event_as_json_no_private (line 123) | def test_event_as_json_no_private(self):
    method test_event_as_html (line 133) | def test_event_as_html(self):
    method test_eventlog (line 146) | def test_eventlog(self):

FILE: mailpile/tests/test_keylookup.py
  class KeylookupBaseTest (line 30) | class KeylookupBaseTest(MailPileUnittest):
    method setUp (line 31) | def setUp(self):
  class KeylookupDNSPKILookup (line 35) | class KeylookupDNSPKILookup(KeylookupBaseTest):
    method test_lookup_dnspki (line 36) | def test_lookup_dnspki(self):
  class KeylookupPGPKeyserverLookup (line 47) | class KeylookupPGPKeyserverLookup(KeylookupBaseTest):
    method test_lookup_pgpkeyserver (line 48) | def test_lookup_pgpkeyserver(self):
  class KeylookupEmailLookup (line 56) | class KeylookupEmailLookup(KeylookupBaseTest):
    method test_lookup_emailkeys (line 57) | def test_lookup_emailkeys(self):
  class KeylookupOverallTest (line 64) | class KeylookupOverallTest(KeylookupBaseTest):
    method test_lookup (line 65) | def test_lookup(self):

FILE: mailpile/tests/test_mail_generator.py
  class TestMailGenerator (line 9) | class TestMailGenerator(MailPileUnittest):
    method test_is8bitstring (line 11) | def test_is8bitstring(self):
    method test_make_boundary (line 18) | def test_make_boundary(self):

FILE: mailpile/tests/test_mailutils.py
  class TestCommands (line 8) | class TestCommands(MailPileUnittest):
    method test_decode_header_no_encoding (line 9) | def test_decode_header_no_encoding(self):

FILE: mailpile/tests/test_performance.py
  function checkSearch (line 7) | def checkSearch(postinglist_kb, query):
  function test_generator (line 19) | def test_generator():

FILE: mailpile/tests/test_plugin.py
  class PluginTest (line 8) | class PluginTest(MailPileUnittest):
    method setUp (line 9) | def setUp(self):
    method tearDown (line 16) | def tearDown(self):
    method test_plugin_is_discovered (line 19) | def test_plugin_is_discovered(self):
    method test_code_files_are_loaded_in_order (line 25) | def test_code_files_are_loaded_in_order(self):
    method _create_manifest (line 55) | def _create_manifest(self, name, json_data):
    method _create_manifest_json (line 64) | def _create_manifest_json(self, name):
    method _create_code_file (line 76) | def _create_code_file(self, content, filename):

FILE: mailpile/tests/test_search.py
  function checkSearch (line 8) | def checkSearch(query, expected_count=1):
  function test_generator (line 23) | def test_generator():

FILE: mailpile/tests/test_ui.py
  class TestUI (line 9) | class TestUI(MailPileUnittest):
    method _ui_swap (line 10) | def _ui_swap(self):
    method test_ui_debug_log_debug_not_set (line 14) | def test_ui_debug_log_debug_not_set(self):
    method test_ui_debug_log_debug_set (line 24) | def test_ui_debug_log_debug_set(self):
    method test_ui_log_block (line 35) | def test_ui_log_block(self):
    method test_ui_clear_log (line 66) | def test_ui_clear_log(self):
    method test_ui_display_result_text (line 85) | def test_ui_display_result_text(self):

FILE: mailpile/tests/test_vcard.py
  class TestVCard (line 6) | class TestVCard(MailPileUnittest):
    method test_VCardLine_with_args (line 8) | def test_VCardLine_with_args(self):
    method test_VCardLine_no_args (line 12) | def test_VCardLine_no_args(self):
    method test_VCardLine_args_too_long (line 18) | def test_VCardLine_args_too_long(self): # when input is greater than 7...
    method test_VCardLine_with_vcard_data (line 24) | def test_VCardLine_with_vcard_data(self):
    method test_VCardLine_set_line_id (line 30) | def test_VCardLine_set_line_id(self):
    method test_VCardLine_set_attr (line 35) | def test_VCardLine_set_attr(self):
    method test_VCardLine_Quote (line 45) | def test_VCardLine_Quote(self):
    method test_VCardLine_ParseLine_unquoted (line 53) | def test_VCardLine_ParseLine_unquoted(self):
    method test_VCardLine_ParseLine_quoted (line 61) | def test_VCardLine_ParseLine_quoted(self):

FILE: mailpile/tests/test_vcard_mork.py
  class TestVCard (line 8) | class TestVCard(MailPileUnittest):
    method test_hexcmp (line 10) | def test_hexcmp(self):

FILE: mailpile/ui.py
  class SuppressHtmlOutput (line 36) | class SuppressHtmlOutput(Exception):
  function default_dict (line 40) | def default_dict(*args):
  class NoColors (line 53) | class NoColors:
    method __init__ (line 72) | def __init__(self):
    method __enter__ (line 78) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 81) | def __exit__(self, *args, **kwargs):
    method color (line 84) | def color(self, text, color='', weight='', readline=False):
    method replace_line (line 88) | def replace_line(self, text, chars=None):
    method clean (line 93) | def clean(self, text):
    method write (line 96) | def write(self, data):
    method buffer (line 100) | def buffer(self, data):
    method check_max_width (line 113) | def check_max_width(self):
  class ANSIColors (line 117) | class ANSIColors(NoColors):
    method __init__ (line 140) | def __init__(self):
    method replace_line (line 144) | def replace_line(self, text, chars=None):
    method clean (line 149) | def clean(self, text):
    method check_max_width (line 152) | def check_max_width(self):
  class Completer (line 164) | class Completer(object):
    method __init__ (line 168) | def __init__(self, session):
    method _available_opts (line 171) | def _available_opts(self, text):
    method _autocomplete (line 177) | def _autocomplete(self, text, state):
    method get_completer (line 183) | def get_completer(self):
  class UserInteraction (line 187) | class UserInteraction:
    method __init__ (line 204) | def __init__(self, config, log_parent=None, log_prefix=None):
    method _fmt_log (line 235) | def _fmt_log(self, text, level=LOG_URGENT):
    method _display_log (line 262) | def _display_log(self, text, level=LOG_URGENT, ring_buffer=None):
    method _debug_log (line 276) | def _debug_log(self, text, level, ring_buffer=None):
    method clear_log (line 291) | def clear_log(self):
    method flush_log (line 294) | def flush_log(self):
    method block (line 303) | def block(self):
    method unblock (line 308) | def unblock(self, force=False):
    method log (line 316) | def log(self, level, message):
    method mark (line 334) | def mark(self, action=None, percent=None):
    method report_marks (line 344) | def report_marks(self, quiet=False, details=False):
    method reset_marks (line 360) | def reset_marks(self, mark=True, quiet=False, details=False):
    method push_marks (line 368) | def push_marks(self, subtask):
    method pop_marks (line 372) | def pop_marks(self, name=None, quiet=True):
    method _display_result (line 381) | def _display_result(self, ttype, result):
    method start_command (line 386) | def start_command(self, cmd, args, kwargs):
    method finish_command (line 393) | def finish_command(self, cmd):
    method _parse_render_mode (line 396) | def _parse_render_mode(self):
    method display_result (line 424) | def display_result(self, result):
    method _make_data_filename (line 464) | def _make_data_filename(self, name_fmt, attributes):
    method _make_data_attributes (line 467) | def _make_data_attributes(self, attributes={}):
    method open_for_data (line 476) | def open_for_data(self, name_fmt=None, attributes={}):
    method render_json (line 482) | def render_json(self, data):
    method _web_template (line 495) | def _web_template(self, config, tpl_names, elems=None):
    method _render_error (line 509) | def _render_error(self, cfg, error_info):
    method render_web (line 532) | def render_web(self, cfg, tpl_names, data):
    method edit_messages (line 575) | def edit_messages(self, session, emails):
    method get_password (line 613) | def get_password(self, prompt):
  class HttpUserInteraction (line 624) | class HttpUserInteraction(UserInteraction):
    method __init__ (line 627) | def __init__(self, request, *args, **kwargs):
    method _display_log (line 634) | def _display_log(self, text, level=UserInteraction.LOG_URGENT, ring_bu...
    method _display_result (line 638) | def _display_result(self, ttype, result):
    method open_for_data (line 642) | def open_for_data(self, name_fmt=None, attributes={}):
    method _render_text_responses (line 645) | def _render_text_responses(self, config):
    method _ttype_to_mimetype (line 654) | def _ttype_to_mimetype(self, ttype, result):
    method render_response (line 667) | def render_response(self, config):
    method edit_messages (line 682) | def edit_messages(self, session, emails):
  class BackgroundInteraction (line 686) | class BackgroundInteraction(UserInteraction):
    method _display_log (line 689) | def _display_log(self, text, level=UserInteraction.LOG_URGENT, ring_bu...
    method edit_messages (line 692) | def edit_messages(self, session, emails):
  class SilentInteraction (line 696) | class SilentInteraction(UserInteraction):
    method _display_log (line 699) | def _display_log(self, text, level=UserInteraction.LOG_URGENT, ring_bu...
    method _display_result (line 702) | def _display_result(self, ttype, result):
    method edit_messages (line 705) | def edit_messages(self, session, emails):
  class CapturingUserInteraction (line 709) | class CapturingUserInteraction(UserInteraction):
    method __init__ (line 710) | def __init__(self, config, **kwargs):
    method _display_result (line 714) | def _display_result(self, ttype, result):
  class RawHttpResponder (line 718) | class RawHttpResponder:
    method __init__ (line 720) | def __init__(self, request, attributes={}):
    method write (line 746) | def write(self, data):
    method close (line 749) | def close(self):
  class Session (line 755) | class Session(object):
    method Snapshot (line 758) | def Snapshot(cls, session, **copy_kwargs):
    method __init__ (line 761) | def __init__(self, config):
    method set_interactive (line 778) | def set_interactive(self, val):
    method copy (line 784) | def copy(self, session, ui=None, copy_ui=False, search=True):
    method get_context (line 800) | def get_context(self, update=False):
    method load_context (line 809) | def load_context(self, context):
    method report_task_completed (line 825) | def report_task_completed(self, name, result):
    method report_task_failed (line 830) | def report_task_failed(self, name):
    method wait_for_task (line 833) | def wait_for_task(self, wait_for, quiet=False):
    method fatal_error (line 843) | def fatal_error(self, message):

FILE: mailpile/urlmap.py
  class BadMethodError (line 16) | class BadMethodError(Exception):
  class BadDataError (line 20) | class BadDataError(Exception):
  class _FancyString (line 24) | class _FancyString(str):
    method __init__ (line 25) | def __init__(self, *args):
  class UrlMap (line 30) | class UrlMap:
    method __init__ (line 53) | def __init__(self, session=None, config=None):
    method _prefix_to_query (line 57) | def _prefix_to_query(self, path, query_data, post_data):
    method _api_commands (line 71) | def _api_commands(self, method, strict=False):
    method _command (line 77) | def _command(self, name,
    method _choose_output (line 185) | def _choose_output(self, path_parts, fmt='html'):
    method _map_root (line 227) | def _map_root(self, request, path_parts, query_data, post_data):
    method _map_tag (line 232) | def _map_tag(self, request, path_parts, query_data, post_data):
    method _map_thread (line 269) | def _map_thread(self, request, path_parts, query_data, post_data):
    method _map_RESERVED (line 292) | def _map_RESERVED(self, *args):
    method _map_api_command (line 295) | def _map_api_command(self, method, path_parts,
    method map (line 336) | def map(self, request, method, path, query_data, post_data,
    method _url (line 452) | def _url(self, url, output='', qs=''):
    method url_thread (line 458) | def url_thread(self, message_id, output=''):
    method url_source (line 462) | def url_source(self, message_id, output=''):
    method url_edit (line 466) | def url_edit(self, message_id, output=''):
    method redirect_to_auth_or_setup (line 470) | def redirect_to_auth_or_setup(self, method, path, query_data, setup=Tr...
    method redirect_to_auth (line 491) | def redirect_to_auth(self, method, path, query_data):
    method url_tag (line 495) | def url_tag(self, tag_id, output=''):
    method url_sent (line 524) | def url_sent(self, output=''):
    method url_search (line 528) | def url_search(self, search_terms, tag=None, output=''):
    method canonical_url (line 558) | def canonical_url(self, cls):
    method ui_url (line 563) | def ui_url(self, cls):
    method context_url (line 567) | def context_url(self, cls):
    method map_as_markdown (line 571) | def map_as_markdown(self, prefix=None):
    method print_map_markdown (line 652) | def print_map_markdown(self):
  class UrlRedirect (line 657) | class UrlRedirect(Command):
    method command (line 662) | def command(self):
  class UrlRedirectEdit (line 666) | class UrlRedirectEdit(Command):
    method command (line 671) | def command(self):
  class UrlRedirectThread (line 676) | class UrlRedirectThread(Command):
    method command (line 681) | def command(self):
  class HelpUrlMap (line 686) | class HelpUrlMap(Command):
    class CommandResult (line 690) | class CommandResult(Command.CommandResult):
      method as_text (line 691) | def as_text(self):
      method as_html (line 694) | def as_html(self, *args, **kwargs):
    method command (line 705) | def command(self):

FILE: mailpile/util.py
  function WhereAmI (line 156) | def WhereAmI(start=1):
  function _TracedLock (line 163) | def _TracedLock(what, *a, **kw):
  function TracedLock (line 193) | def TracedLock(*args, **kwargs):
  function TracedRLock (line 197) | def TracedRLock(*args, **kwargs):
  class WorkerError (line 219) | class WorkerError(Exception):
  class UsageError (line 223) | class UsageError(Exception):
  class AccessError (line 227) | class AccessError(Exception):
  class InternalError (line 231) | class InternalError(AssertionError):
  class UrlRedirectException (line 235) | class UrlRedirectException(Exception):
    method __init__ (line 237) | def __init__(self, url):
  class JobPostponingException (line 242) | class JobPostponingException(Exception):
  class MultiContext (line 246) | class MultiContext:
    method __init__ (line 247) | def __init__(self, contexts):
    method __enter__ (line 250) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 255) | def __exit__(self, *args, **kwargs):
  function safe_assert (line 266) | def safe_assert(check, *args):
  function thread_context_push (line 272) | def thread_context_push(**kwargs):
  function thread_context (line 278) | def thread_context():
  function thread_context_pop (line 282) | def thread_context_pop():
  function FixupForWith (line 287) | def FixupForWith(obj):
  function b64c (line 295) | def b64c(b):
  function b64w (line 311) | def b64w(b):
  function escape_html (line 324) | def escape_html(t):
  function flip_unicode_boxes (line 343) | def flip_unicode_boxes(text):
  function _hash (line 347) | def _hash(cls, data):
  function sha1b64 (line 357) | def sha1b64(*data):
  function sha512b64 (line 374) | def sha512b64(*data):
  function md5_hex (line 390) | def md5_hex(*data):
  function strhash (line 394) | def strhash(s, length, obfuscate=None):
  function b36 (line 420) | def b36(number):
  function string_to_rank (line 443) | def string_to_rank(text, maxint=sys.maxsize):
  function string_to_intlist (line 457) | def string_to_intlist(text):
  function intlist_to_string (line 465) | def intlist_to_string(intlist):
  function intlist_to_bitmask (line 473) | def intlist_to_bitmask(intlist):
  function bitmask_to_intlist (line 482) | def bitmask_to_intlist(bitmask):
  function truthy (line 491) | def truthy(txt, default=False, special=None):
  function try_decode (line 513) | def try_decode(text, charset, replace=''):
  function randomish_uid (line 527) | def randomish_uid():
  function okay_random (line 542) | def okay_random(length, *seeds):
  function split_secret (line 561) | def split_secret(secret, recipients, pad_to=24):
  function merge_secret (line 578) | def merge_secret(parts):
  function reflow_text (line 594) | def reflow_text(text, quoting=False, target_width=65):
  function elapsed_datetime (line 652) | def elapsed_datetime(timestamp):
  function friendly_datetime (line 693) | def friendly_datetime(timestamp):
  function friendly_time (line 698) | def friendly_time(timestamp):
  function friendly_number (line 703) | def friendly_number(number, base=1000, decimals=0, suffix='',
  function decrypt_and_parse_lines (line 730) | def decrypt_and_parse_lines(fd, parser, config,
  function safe_remove (line 774) | def safe_remove(filename=None):
  function backup_file (line 787) | def backup_file(filename, backups=5, min_age_delta=0):
  function get_free_disk_bytes (line 804) | def get_free_disk_bytes(dirname):
  function json_helper (line 815) | def json_helper(obj):
  class GpgWriter (line 821) | class GpgWriter(object):
    method __init__ (line 822) | def __init__(self, gpg):
    method __enter__ (line 826) | def __enter__(self):
    method __exit__ (line 829) | def __exit__(self, exc_type, exc_val, exc_tb):
    method write (line 833) | def write(self, data):
    method close (line 836) | def close(self):
  function dict_merge (line 841) | def dict_merge(*dicts):
  function user_probably_asleep (line 855) | def user_probably_asleep():
  function play_nice (line 865) | def play_nice(niceness):
  function play_nice_with_threads (line 875) | def play_nice_with_threads(sleep=True, weak=False, deadline=None):
  class PeekableStringIO (line 908) | class PeekableStringIO(StringIO.StringIO):
    method peek (line 909) | def peek(self, n):
  function squish_mimetype (line 949) | def squish_mimetype(mimetype):
  function unsquish_mimetype (line 956) | def unsquish_mimetype(mimetype):
  function image_size (line 963) | def image_size(img_data, pure_python=False):
  function thumbnail (line 974) | def thumbnail(fileobj, output_fd, height=None, width=None):
  class CleanText (line 1044) | class CleanText:
    method __init__ (line 1083) | def __init__(self, text, banned='', replace=''):
    method __str__ (line 1089) | def __str__(self):
    method __unicode__ (line 1092) | def __unicode__(self):
  function HideBinary (line 1096) | def HideBinary(text):
  class TimedOut (line 1104) | class TimedOut(IOError):
  class RunTimedThread (line 1112) | class RunTimedThread(threading.Thread):
    method __init__ (line 1113) | def __init__(self, name, func, unique=None):
    method run_timed (line 1119) | def run_timed(self, timeout):
  function RunTimed (line 1138) | def RunTimed(timeout, func, *args, **kwargs):
  class DebugFileWrapper (line 1157) | class DebugFileWrapper(object):
    method __init__ (line 1158) | def __init__(self, dbg, fd):
    method __getattribute__ (line 1162) | def __getattribute__(self, name):
    method write (line 1169) | def write(self, data, *args, **kwargs):
    method flush (line 1174) | def flush(self, *args, **kwargs):
    method close (line 1178) | def close(self, *args, **kwargs):
  function monkey_patch (line 1183) | def monkey_patch(org_func, wrapper):

FILE: mailpile/vcard.py
  class VCardLine (line 16) | class VCardLine(dict):
    method __init__ (line 66) | def __init__(self, line=None, name=None, value=None, **attrs):
    method set_line_id (line 78) | def set_line_id(self, value):
    method set_name (line 86) | def set_name(self, value):
    method set_value (line 90) | def set_value(self, value):
    method set_attrs (line 94) | def set_attrs(self, value):
    method set_attr (line 98) | def set_attr(self, attr, value):
    method parse (line 121) | def parse(self, line):
    method _update_dict (line 125) | def _update_dict(self):
    method __delitem__ (line 134) | def __delitem__(self, *args, **kwargs):
    method __setitem__ (line 137) | def __setitem__(self, *args, **kwargs):
    method update (line 140) | def update(self, *args, **kwargs):
    method as_vcardline (line 143) | def as_vcardline(self):
    method Quote (line 166) | def Quote(self, text):
    method ParseLine (line 176) | def ParseLine(self, text):
  class SimpleVCard (line 228) | class SimpleVCard(object):
    method __init__ (line 336) | def __init__(self, *lines, **kwargs):
    method _cardinality (line 350) | def _cardinality(self, vcl):
    method __enter__ (line 359) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 362) | def __exit__(self, *args, **kwargs):
    method remove (line 365) | def remove(self, *line_ids):
    method remove_all (line 389) | def remove_all(self, name):
    method _handle_pidmap_args (line 402) | def _handle_pidmap_args(self, **kwargs):
    method add (line 413) | def add(self, *vcls, **kwargs):
    method set_line (line 458) | def set_line(self, ln, vcl, **kwargs):
    method get_clientpidmap (line 484) | def get_clientpidmap(self):
    method get_pidmap (line 519) | def get_pidmap(self, src_id, create=False):
    method merge (line 555) | def merge(self, src_id, lines):
    method get_all (line 677) | def get_all(self, key, sort=False):
    method get (line 684) | def get(self, key, default=None, n=0, prefer=None):
    method _sort_lines (line 698) | def _sort_lines(self, lines=None):
    method as_jCard (line 726) | def as_jCard(self):
    method as_vCard (line 733) | def as_vCard(self):
    method as_lines (line 758) | def as_lines(self):
    method _vcard_get (line 763) | def _vcard_get(self, key, default=None):
    method _vcard_set (line 771) | def _vcard_set(self, key, value):
  class MailpileVCard (line 798) | class MailpileVCard(SimpleVCard):
    method __init__ (line 808) | def __init__(self, *lines, **kwargs):
    method configure_encryption (line 821) | def configure_encryption(self, config):
    method _mpcdict (line 833) | def _mpcdict(self, vcl):
    method as_mpCard (line 853) | def as_mpCard(self):
    method load (line 873) | def load(self, filename=None, data=None, config=None):
    method save (line 908) | def save(self, filename=None):
    method _history_parse_expire (line 931) | def _history_parse_expire(self, history_vcl, now):
    method recent_history (line 950) | def recent_history(self, now=None):
    method record_history (line 958) | def record_history(self, what, when, mid, now=None):
    method same_domain (line 971) | def same_domain(self, address):
    method _random_uid (line 978) | def _random_uid(self):
    method prefer_sender (line 991) | def prefer_sender(self, address, sender):
    method sending_profile (line 1002) | def sending_profile(self, address):
    method add_scope (line 1048) | def add_scope(self, scope):
    method sends_to (line 1055) | def sends_to(self, address):
    method add_source (line 1064) | def add_source(self, source_id):
    method get_source_by_proto (line 1070) | def get_source_by_proto(self, protocol, create=False, name=None):
    method sources (line 1097) | def sources(self):
  class AddressInfo (line 1116) | class AddressInfo(dict):
    method __init__ (line 1150) | def __init__(self, addr, fn, vcard=None, rank=0, proto='smtp', keys=No...
    method merge_vcard (line 1165) | def merge_vcard(self, vcard):
  class VCardStore (line 1200) | class VCardStore(dict):
    method __init__ (line 1233) | def __init__(self, config, vcard_dir):
    method __enter__ (line 1241) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 1244) | def __exit__(self, *args, **kwargs):
    method index_vcard (line 1247) | def index_vcard(self, card, collision_callback=None):
    method deindex_vcard (line 1267) | def deindex_vcard(self, card):
    method load_vcards (line 1280) | def load_vcards(self, session=None):
    method get_vcard (line 1336) | def get_vcard(self, email):
    method find_vcards_with_line (line 1339) | def find_vcards_with_line(vcards, name, value):
    method find_vcards (line 1346) | def find_vcards(vcards, terms, kinds=None):
    method add_vcards (line 1366) | def add_vcards(self, *cards):
    method del_vcards (line 1375) | def del_vcards(self, *cards):
    method choose_from_address (line 1380) | def choose_from_address(vcards, *args, **kwargs):
    method choose_from_addresses (line 1452) | def choose_from_addresses(vcards, config, *address_lists):
  class VCardPluginClass (line 1509) | class VCardPluginClass:
    method __init__ (line 1517) | def __init__(self, session, config, guid=None):
  class VCardImporter (line 1530) | class VCardImporter(VCardPluginClass):
    method get_guid (line 1534) | def get_guid(self, vcard):
    method import_vcards (line 1537) | def import_vcards(self, session, vcard_store, **kwargs):
    method get_vcards (line 1617) | def get_vcards(self):
  class VCardExporter (line 1621) | class VCardExporter(VCardPluginClass):
    method __init__ (line 1623) | def __init__(self):
    method add_contact (line 1626) | def add_contact(self, contact):
    method remove_contact (line 1629) | def remove_contact(self, contact):
    method save (line 1632) | def save(self):
  class VCardContextProvider (line 1636) | class VCardContextProvider(VCardPluginClass):
    method __init__ (line 1638) | def __init__(self, contact):
    method get_recent_context (line 1641) | def get_recent_context(self, max=10):
    method get_related_context (line 1644) | def get_related_context(self, query, max=10):

FILE: mailpile/vfs.py
  function register_handler (line 33) | def register_handler(prio, obj):
  function register_alias (line 38) | def register_alias(name, prefix):
  class FilePath (line 44) | class FilePath(object):
    method __init__ (line 54) | def __init__(self, cooked_fp=None, binary_fp=None, flags=None):
    method unalias (line 72) | def unalias(self, fp):
    method alias (line 80) | def alias(self, fp):
    method __unicode__ (line 91) | def __unicode__(self, errors='strict'):
    method __str__ (line 99) | def __str__(self):
    method __eq__ (line 103) | def __eq__(self, other):
    method encoded (line 106) | def encoded(self):
    method display (line 109) | def display(self):
    method display_basename (line 113) | def display_basename(self):
    method startswith (line 117) | def startswith(self, stuff): return self.raw_fp.startswith(stuff)
    method endswith (line 118) | def endswith(self, stuff): return self.raw_fp.endswith(stuff)
    method lower (line 119) | def lower(self): return self.__unicode__('replace').lower()
    method upper (line 120) | def upper(self): return self.__unicode__('replace').upper()
    method join (line 122) | def join(self, *fpaths):
  class MailpileVfsBase (line 128) | class MailpileVfsBase(object):
    method __init__ (line 134) | def __init__(self):
    method Handles (line 138) | def Handles(cls, path):
    method path_join (line 143) | def path_join(cls, fp, *fps):
    method open (line 146) | def open(cls, fp, *args, **kwargs):
    method open_mailbox (line 150) | def open_mailbox(cls, fp, *args, **kwargs):
    method glob (line 153) | def glob(cls, fp, *args, **kwargs):
    method listdir (line 157) | def listdir(cls, fp, *args, **kwargs):
    method getinfo (line 161) | def getinfo(cls, fp, config):
    method getinfo_ (line 164) | def getinfo_(cls, fp, config):
    method display_name (line 179) | def display_name(cls, fp, config):
    method display_name_ (line 182) | def display_name_(cls, fp, config):
    method abspath (line 185) | def abspath(cls, fp):
    method getflags (line 188) | def getflags(cls, fp, config):
    method getflags_ (line 191) | def getflags_(cls, fp, config):
    method isdir (line 205) | def isdir(cls, fp):
    method ismailsource (line 208) | def ismailsource(cls, fp):
    method mailbox_type (line 211) | def mailbox_type(cls, fp, config):
    method getsize (line 214) | def getsize(cls, fp):
    method exists (line 217) | def exists(cls, fp):
    method _fixme (line 220) | def _fixme(self):
  class MailpileVFS (line 234) | class MailpileVFS(MailpileVfsBase):
    method _delegate (line 239) | def _delegate(cls, path):
    method glob_ (line 245) | def glob_(self, path, *args, **kwargs):
    method open_ (line 248) | def open_(self, path, *args, **kwargs):
    method listdir_ (line 251) | def listdir_(self, path, *args, **kwargs):
    method abspath_ (line 254) | def abspath_(self, path, *args, **kwargs):
    method isdir_ (line 257) | def isdir_(self, path, *args, **kwargs):
    method getflags_ (line 260) | def getflags_(self, path, *args, **kwargs):
    method ismailsource_ (line 263) | def ismailsource_(self, path, *args, **kwargs):
    method mailbox_type_ (line 266) | def mailbox_type_(self, path, config):
    method getsize_ (line 269) | def getsize_(self, path, *args, **kwargs):
    method display_name_ (line 272) | def display_name_(self, path, *args, **kwargs):
    method exists_ (line 275) | def exists_(self, path, *args, **kwargs):
  class MailpileVfsLocal (line 279) | class MailpileVfsLocal(MailpileVfsBase):
    method Handles (line 288) | def Handles(cls, path):
    method glob_ (line 291) | def glob_(self, *args, **kwargs): return glob.iglob(*args, **kwargs)
    method open_ (line 292) | def open_(self, *args, **kwargs): return open(*args, **kwargs)
    method listdir_ (line 293) | def listdir_(self, *args, **kwargs): return os.listdir(*args, **kwargs)
    method abspath_ (line 294) | def abspath_(self, path): return os.path.abspath(path)
    method isdir_ (line 295) | def isdir_(self, path): return os.path.isdir(path)
    method ismailsource_ (line 296) | def ismailsource_(self, fp): return False
    method mailbox_type_ (line 297) | def mailbox_type_(self, path, config):
    method getsize_ (line 300) | def getsize_(self, path): return os.path.getsize(path)
    method exists_ (line 301) | def exists_(self, path): return os.path.exists(path)
  class MailpileVfsRoot (line 304) | class MailpileVfsRoot(MailpileVfsBase):
    method __init__ (line 314) | def __init__(self, config):
    method rescan (line 318) | def rescan(self):
    method _discover_mail_spool (line 328) | def _discover_mail_spool(self):
    method _discover_local_mailboxes (line 339) | def _discover_local_mailboxes(self):
    method _discover_thunderbird (line 354) | def _discover_thunderbird(self):
    method _entries (line 365) | def _entries(self):
    method Handles (line 373) | def Handles(self, path):
    method glob_ (line 377) | def glob_(self, *args, **kwargs):
    method listdir_ (line 380) | def listdir_(self, fp, *args, **kwargs):
    method display_name_ (line 383) | def display_name_(self, fp, config):
    method open_ (line 389) | def open_(self, fp, *args, **kwargs):
    method abspath_ (line 392) | def abspath_(self, fp):
    method isdir_ (line 396) | def isdir_(self, fp):
    method ismailsource_ (line 399) | def ismailsource_(self, fp):
    method mailbox_type_ (line 403) | def mailbox_type_(self, fp, config):
    method getsize_ (line 408) | def getsize_(self, fp):
    method exists_ (line 411) | def exists_(self, fp):

FILE: mailpile/workers.py
  class Cron (line 16) | class Cron(threading.Thread):
    method __init__ (line 22) | def __init__(self, schedule, name=None, session=None):
    method __str__ (line 44) | def __str__(self):
    method add_task (line 48) | def add_task(self, name, interval, task):
    method __recalculateSleep (line 75) | def __recalculateSleep(self):
    method cancel_task (line 91) | def cancel_task(self, name):
    method run (line 105) | def run(self):
    method quit (line 160) | def quit(self, session=None, join=True):
  class Worker (line 174) | class Worker(threading.Thread):
    method __init__ (line 179) | def __init__(self, name, session, daemon=False):
    method __str__ (line 194) | def __str__(self):
    method add_task (line 201) | def add_task(self, session, name, task,
    method add_unique_task (line 223) | def add_unique_task(self, session, name, task, **kwargs):
    method do (line 226) | def do(self, session, name, task, unique=False, first=False):
    method _pause_for_user_activities (line 243) | def _pause_for_user_activities(self):
    method _keep_running (line 249) | def _keep_running(self, **ignored_kwargs):
    method _failed (line 252) | def _failed(self, session, name, task, e):
    method is_idle (line 259) | def is_idle(self):
    method run (line 264) | def run(self):
    method pause (line 306) | def pause(self, session, first=False):
    method unpause (line 319) | def unpause(self, session):
    method die_soon (line 325) | def die_soon(self, session=None):
    method quit (line 330) | def quit(self, session=None, join=True):
  class ImportantWorker (line 336) | class ImportantWorker(Worker):
    method _pause_for_user_activities (line 341) | def _pause_for_user_activities(self):
    method _keep_running (line 346) | def _keep_running(self, _pass=1, locked=False):
    method _failed (line 369) | def _failed(self, session, name, task, e):
  class DumbWorker (line 375) | class DumbWorker(Worker):
    method add_task (line 376) | def add_task(self, session, name, task, unique=False):
    method add_unique_task (line 380) | def add_unique_task(self, session, name, task, **kwargs):
    method do (line 383) | def do(self, session, name, task, unique=False):
    method run (line 386) | def run(self):
    method die_soon (line 389) | def die_soon(self, *args, **kwargs):
    method quit (line 392) | def quit(self, *args, **kwargs):

FILE: mailpile/www/jinjaextensions.py
  class MailpileCommand (line 44) | class MailpileCommand(Extension):
    method __init__ (line 48) | def __init__(self, environment):
    method _debug (line 185) | def _debug(self, msg):
    method _command (line 192) | def _command(self, command, *args, **kwargs):
    method _command_render (line 198) | def _command_render(self, how, command, *args, **kwargs):
    method _use_data_view (line 214) | def _use_data_view(self, view_name, result):
    method _get_ui_elements (line 219) | def _get_ui_elements(self, ui_type, state, context=None):
    method _add_state_query_string (line 225) | def _add_state_query_string(cls, url, state, elem=None):
    method _ui_elements_setup (line 253) | def _ui_elements_setup(self, classfmt, elements):
    method _regex_replace (line 266) | def _regex_replace(self, s, find, replace):
    method _friendly_received (line 270) | def _friendly_received(self, data):
    method _friendly_number (line 284) | def _friendly_number(self, number, decimals=0):
    method _friendly_bytes (line 290) | def _friendly_bytes(self, number, decimals=0):
    method _body_part_metadata (line 297) | def _body_part_metadata(self, bp):
    method _friendly_hex_bytes (line 320) | def _friendly_hex_bytes(self, number, decimals=0):
    method _show_avatar (line 327) | def _show_avatar(self, contact):
    method _navigation_on (line 335) | def _navigation_on(self, search_tag_ids, on_tid):
    method _has_label_tags (line 343) | def _has_label_tags(self, tags, tag_tids):
    method _show_text_part_signature (line 482) | def _show_text_part_signature(self, status):
    method _show_message_signature (line 493) | def _show_message_signature(self, status):
    method _show_text_part_encryption (line 571) | def _show_text_part_encryption(self, status):
    method _show_message_encryption (line 582) | def _show_message_encryption(self, status):
    method _show_crypto_policy (line 623) | def _show_crypto_policy(self, policy):
    method _contact_url (line 638) | def _contact_url(self, person):
    method _contact_name (line 652) | def _contact_name(self, person):
    method _thread_upside_down (line 662) | def _thread_upside_down(self, thread):
    method _fix_urls (line 689) | def _fix_urls(self, text, truncate=45, danger=False):
    method _min (line 727) | def _min(self, sequence):
    method _max (line 731) | def _max(self, sequence):
    method _random (line 735) | def _random(self, sequence):
    method _truthy (line 739) | def _truthy(cls, txt, default=False):
    method _is_dev_version (line 742) | def _is_dev_version(self):
    method _is_configured (line 745) | def _is_configured(self):
    method _version_identifier (line 749) | def _version_identifier(cls):
    method _with_context (line 752) | def _with_context(self, sequence, context=1):
    method _url_path_fix (line 757) | def _url_path_fix(self, *urlparts):
    method _urlencode (line 765) | def _urlencode(self, s):
    method _selectattr (line 770) | def _selectattr(self, seq, attr, value=None):
    method _safe (line 776) | def _safe(self, s):
    method _json (line 782) | def _json(self, d):
    method _escapejs (line 802) | def _escapejs(self, value):
    method _nice_text (line 812) | def _nice_text(self, text):
    method _to_br (line 827) | def _to_br(self, text):
    method _nice_subject (line 836) | def _nice_subject(self, subject):
    method _bare_subject (line 844) | def _bare_subject(self, subject):
    method _get_all (line 852) | def _get_all(self, pairs, name):
    method _get_addresses (line 855) | def _get_addresses(self, pairs, name):
    method _nice_name (line 871) | def _nice_name(self, name, truncate=100):
    method _recipient_summary (line 877) | def _recipient_summary(self, editing_strings, addresses, truncate):
    method _attachment_type (line 893) | def _attachment_type(self, mime):
    method _theme_settings (line 1035) | def _theme_settings(self):
    method _nice_fingerprint (line 1040) | def _nice_fingerprint(self, fingerprint):
    method _group_fingerprint (line 1050) | def _group_fingerprint(self, fingerprint, size=4):
    method _make_filter_groups (line 1056) | def _make_filter_groups(self, tags):
    method _show_nagification (line 1071) | def _show_nagification(self, nag):

FILE: mailpile/www/jinjaloader.py
  class MailpileJinjaLoader (line 6) | class MailpileJinjaLoader(BaseLoader):
    method __init__ (line 11) | def __init__(self, config):
    method get_template_path (line 14) | def get_template_path(self, tpl):
    method get_source (line 17) | def get_source(self, environment, template):

FILE: packages/macos/brew/symlinks.rb
  class Symlinks (line 1) | class Symlinks < Formula
    method install (line 7) | def install

FILE: packages/macos/dmgbuild-settings.py
  function icon_from_app (line 11) | def icon_from_app(app_path):

FILE: packages/scripts/build-controller.py
  class ArgumentError (line 17) | class ArgumentError(Exception):
  function config_assert (line 21) | def config_assert(condition):
  class BuildbotController (line 26) | class BuildbotController(object):
    method __init__ (line 34) | def __init__(self):
    method load_config (line 43) | def load_config(self, filename=None):
    method parse_with_common_args (line 53) | def parse_with_common_args(self, args, opt_flags='', opt_args=[]):
    method cmd_hello (line 78) | def cmd_hello(self, args):
    method cmd_win (line 82) | def cmd_win(self, args):
    method cmd_mac (line 87) | def cmd_mac(self, args):
    method cmd_run (line 92) | def cmd_run(self, args):
    method cmd_status (line 97) | def cmd_status(self, args):
    method cmd_wait (line 102) | def cmd_wait(self, args):
    method parse_args (line 111) | def parse_args(self, args):
    method run (line 121) | def run(self):
    method cleanup (line 124) | def cleanup(self):
    method Main (line 128) | def Main(cls, args):

FILE: packages/scripts/build-desktop.py
  class Sub (line 21) | class Sub(object):
    method __init__ (line 22) | def __init__(self, command, env=None):
    method communicate (line 27) | def communicate(self):
    method __str__ (line 38) | def __str__(self):
  function run (line 44) | def run(*args, **kwargs):
  function git (line 57) | def git(*args, **kwargs):
  function macOS_build (line 63) | def macOS_build(mailpile_tree, repo, branch, clean_build):
  function windows_build (line 73) | def windows_build(mailpile_tree, repo, branch, clean_build):

FILE: packages/scripts/kite-runner.py
  class ArgumentError (line 22) | class ArgumentError(Exception):
  class Killed (line 26) | class Killed(Exception):
  class OutputEater (line 30) | class OutputEater(threading.Thread):
    method __init__ (line 31) | def __init__(self, fd, callback):
    method run (line 37) | def run(self):
  class PagekiteThread (line 46) | class PagekiteThread(threading.Thread):
    method __init__ (line 47) | def __init__(self, server):
    method _handle_logline (line 53) | def _handle_logline(self, line):
    method run (line 56) | def run(self):
    method _run (line 62) | def _run(self):
    method reap (line 102) | def reap(self):
    method quit (line 109) | def quit(self):
  class BuildbotXMLRPCServer (line 114) | class BuildbotXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer):
    method __init__ (line 115) | def __init__(self, config, *args, **kwargs):
  class BuildbotRequestHandler (line 120) | class BuildbotRequestHandler(SimpleXMLRPCServer.SimpleXMLRPCRequestHandl...
    method __init__ (line 121) | def __init__(self, request, client_address, server):
  class BuildbotAPI (line 127) | class BuildbotAPI(object):
    method __init__ (line 128) | def __init__(self, server):
    method _collect_stdout (line 135) | def _collect_stdout(self, sdata, logline):
    method _collect_stderr (line 145) | def _collect_stderr(self, sdata, logline):
    method status (line 149) | def status(self, name, error='No matching script logs found'):
    method run (line 158) | def run(self, name, delay):
    method test (line 184) | def test(self, arg):
    method quit (line 187) | def quit(self):
  class BuildbotServer (line 193) | class BuildbotServer(object):
    method __init__ (line 203) | def __init__(self):
    method load_config (line 219) | def load_config(self, filename=None):
    method _set_uid_and_gid (line 229) | def _set_uid_and_gid(self, identity):
    method subprocess_env (line 241) | def subprocess_env(self):
    method parse_with_common_args (line 249) | def parse_with_common_args(self, args, opt_flags='', opt_args=[]):
    method parse_args (line 304) | def parse_args(self, args):
    method launch_xmlrpc_server (line 308) | def launch_xmlrpc_server(self):
    method run (line 317) | def run(self):
    method cleanup (line 326) | def cleanup(self):
  function kite_runner_main (line 332) | def kite_runner_main(args):

FILE: packages/windows-wix/bin/with-mailpile-env.py
  function locate_parent (line 23) | def locate_parent( path_parts ):
  function split_args (line 41) | def split_args( args = sys.argv[1:] ):

FILE: packages/windows-wix/package.py
  function consume (line 39) | def consume(iterator, n=None):
  function xml_attrs (line 50) | def xml_attrs( xml_element, **attrs ):
  function xml_append (line 53) | def xml_append( xml_parent, xml_element_type, **attrs ):
  class WixConfig (line 58) | class WixConfig( object ):
    method __init__ (line 70) | def __init__( self, config ):
    method post_install (line 212) | def post_install( self ):
    method config_ui (line 230) | def config_ui( self, flavor = 'WixUI_Advanced', variables = {} ):
    method logical_node (line 316) | def logical_node( self, parent_id, **attrs ):
    method logical_root (line 324) | def logical_root( self, **attrs ):
    method uuid (line 332) | def uuid( self, path, local_path = None ):
    method directory (line 389) | def directory( self, path ):
    method id_str (line 418) | def id_str( self, use, name ):
    method directory_id (line 432) | def directory_id( self, path ):
    method component_id (line 435) | def component_id( self, name ):
    method file_id (line 438) | def file_id( self, name ):
    method mask_path (line 441) | def mask_path( self, mask, path ):
    method scan_group (line 447) | def scan_group( self, name, uuid, root, ignore = [], shortcuts = {} ):
    method save (line 515) | def save( self, path, indent = 2 ):

FILE: packages/windows-wix/provide/build.py
  class Build (line 13) | class Build(object):
    class Invoker (line 19) | class Invoker(object):
      method __init__ (line 26) | def __init__(self, build, exe, method=subprocess.check_output):
      method __call__ (line 34) | def __call__(self, *args):
    class Context (line 58) | class Context(object):
      method __init__ (line 63) | def __init__(self, build, cache, config):
      method cache (line 77) | def cache(self):
      method log (line 84) | def log(self):
      method depend (line 91) | def depend(self, keyword):
      method cleanup (line 109) | def cleanup(self, action):
      method publish (line 116) | def publish(self, keyword, invoker):
      method invoke (line 127) | def invoke(self, keyword, *args, **kwargs):
      method clear (line 134) | def clear(self):
      method config (line 145) | def config(self, keyword):
      method __enter__ (line 157) | def __enter__(self):
      method __exit__ (line 162) | def __exit__(self, type, value, traceback):
    method __init__ (line 171) | def __init__(self):
    method provide (line 180) | def provide(self, *keywords, **extra):
    method default_config (line 191) | def default_config(self, *keywords, **extra):
    method define_config (line 202) | def define_config(self, keyword, doc):
    method context (line 208) | def context(self, cache, config={}):
    method parser (line 214) | def parser(self, parser=None):
    method parse_config (line 235) | def parse_config(self, args):

FILE: packages/windows-wix/provide/cache.py
  class Cache (line 17) | class Cache(object):
    method chunk_stream (line 24) | def chunk_stream(src_read, dst_write, chunk_size=4096):
    method default_cache_dir (line 33) | def default_cache_dir():
    method __init__ (line 38) | def __init__(self, cache_dir=None):
    method download (line 45) | def download(cls, url, writer, **kwargs):
    method sha1_handle (line 65) | def sha1_handle(cls, handle, **kwargs):
    method sha1_file (line 71) | def sha1_file(cls, target, **kwargs):
    method __paths_for (line 75) | def __paths_for(self, url, sha1):
    method __cache_handle (line 81) | def __cache_handle(self, url, sha1, handle, **kwargs):
    method __fetch (line 99) | def __fetch(self, url, sha1, **kwargs):
    method __open (line 128) | def __open(self, url, sha1, **kwargs):
    method resolve (line 147) | def resolve(self, url, sha1, **kwargs):
    method insert (line 154) | def insert(self, url, **kwargs):
  class SemanticCache (line 158) | class SemanticCache(object):
    method __init__ (line 163) | def __init__(self, resources, cache=None):
    method resource (line 170) | def resource(self, name):
    method insert (line 177) | def insert(self, key, url, comment = None):
    method save (line 191) | def save(self, path, indent=2):
    method preload (line 198) | def preload(self):
    method load (line 206) | def load(cls, path, cache=None):

FILE: packages/windows-wix/provide/default.py
  function import_file (line 19) | def import_file(name):
  function import_file (line 25) | def import_file(name):

FILE: packages/windows-wix/provide/scripts/bootstrap.py
  function bind (line 10) | def bind(framework):

FILE: packages/windows-wix/provide/scripts/export.py
  function bind (line 4) | def bind(build):

FILE: packages/windows-wix/provide/scripts/external.py
  function bind (line 5) | def bind(build):

FILE: packages/windows-wix/provide/scripts/extract_msi.py
  class LessMSI (line 21) | class LessMSI(object):
    method __init__ (line 26) | def __init__(self, lessmsi_path):
    method __call__ (line 29) | def __call__(self, msi_path, out_path, features=ALL):
  function bind (line 63) | def bind(build):

FILE: packages/windows-wix/provide/scripts/git_checkout.py
  function bind (line 4) | def bind(build):

FILE: packages/windows-wix/provide/scripts/msi_package.py
  function format_pod (line 20) | def format_pod(template, **kwargs):
  function bind (line 41) | def bind(build):

FILE: packages/windows-wix/provide/scripts/python27.py
  function bind (line 6) | def bind(framework):

FILE: packages/windows-wix/provide/scripts/root.py
  function bind (line 5) | def bind(build):

FILE: packages/windows-wix/provide/scripts/sign_tree.py
  function is_signable (line 4) | def is_signable(path):
  function bind (line 20) | def bind(build):

FILE: packages/windows-wix/provide/scripts/util.py
  class TemporaryScope (line 12) | class TemporaryScope(object):
    method __init__ (line 40) | def __init__(self, deleter):
    method __enter__ (line 43) | def __enter__(self):
    method __exit__ (line 47) | def __exit__(self, *ignored):
    method named_file (line 53) | def named_file(self, *args, **kwargs):
    method named_dir (line 59) | def named_dir(self, *args, **kwargs):
  class Util (line 65) | class Util(object):
    method rmtree (line 71) | def rmtree(path):
    method temporary_scope (line 93) | def temporary_scope(cls):
    method publish_exes (line 101) | def publish_exes(build, path):
    method tempdir (line 112) | def tempdir(*args, **kwargs):
    method pushdir (line 126) | def pushdir(path):
  function bind (line 138) | def bind(build):

FILE: packages/windows-wix/provide/scripts/version.py
  function bind (line 1) | def bind(framework):

FILE: packages/windows-wix/provide/scripts/win4gpg.py
  function bind (line 5) | def bind(build):

FILE: packages/windows-wix/provide/scripts/zip.py
  function bind (line 4) | def bind(build):

FILE: scripts/colorprints.py
  function colorprint (line 70) | def colorprint(fingerprint, md5shift=True, mixer=[4, 8, 4]):
  function colorprint2 (line 127) | def colorprint2(fingerprint, md5shift=True):
  function tohtml (line 199) | def tohtml(cprint, brk=False):
  function toangel (line 209) | def toangel(slices, fingerprint, copy=True, size=64):

FILE: scripts/create-debian-changelog.py
  function getLogMessage (line 8) | def getLogMessage(commitSHA):
  function versionFromCommitNo (line 13) | def versionFromCommitNo(commitNo):

FILE: scripts/mailpile-decrypt.py
  function parser (line 83) | def parser(lines):

FILE: scripts/mailpile-pyside.py
  class Window (line 12) | class Window(QWidget):
    method __init__ (line 13) | def __init__(self):
    method setupInspector (line 29) | def setupInspector(self):
    method toggleInspector (line 40) | def toggleInspector(self):
  function main (line 43) | def main():

FILE: scripts/mailpile-test.py
  function contents (line 60) | def contents(fn):
  function grep (line 64) | def grep(w, fn):
  function grepv (line 68) | def grepv(w, fn):
  function say (line 72) | def say(stuff):
  function do_setup (line 79) | def do_setup():
  function test_vcards (line 128) | def test_vcards():
  function test_load_save_rescan (line 138) | def test_load_save_rescan():
  function test_message_data (line 196) | def test_message_data():
  function test_composition (line 237) | def test_composition():
  function test_smtp (line 329) | def test_smtp():
  function test_html (line 350) | def test_html():

FILE: scripts/mbox-minimal.py
  function find_message_id (line 12) | def find_message_id(buf, LE, LFLF):

FILE: setup.py
  function _get_submodules (line 24) | def _get_submodules(git_dir):
  function _find_git_files (line 31) | def _find_git_files(dirname='', git_dir=None):
  class Builder (line 67) | class Builder(build_py):
    method run (line 68) | def run(self):

FILE: shared-data/contrib/datadig/datadig.js
  function preview (line 3) | function preview() {
  function add_column (line 20) | function add_column() {
  function set_column_from_hint (line 27) | function set_column_from_hint(i, elem) {
  function show_hints (line 33) | function show_hints() {
  function download (line 39) | function download() {

FILE: shared-data/contrib/datadig/datadig.py
  class dataDigCommand (line 17) | class dataDigCommand(Command):
    class CommandResult (line 31) | class CommandResult(Command.CommandResult):
      method as_text (line 32) | def as_text(self):
    method _filter (line 39) | def _filter(self, idx, e, celldata, filters):
    method _cell (line 47) | def _cell(self, idx, e, cellspec):
    method command (line 73) | def command(self):

FILE: shared-data/contrib/demos/demos.py
  class DemoVCardImporter (line 39) | class DemoVCardImporter(VCardImporter):
    method get_vcards (line 54) | def get_vcards(self):
  function TickJob (line 75) | def TickJob(session):
  class md5sumCommand (line 95) | class md5sumCommand(Command):
    method command (line 104) | def command(self):
  class md5sumWordyView (line 120) | class md5sumWordyView(md5sumCommand):
    method view (line 123) | def view(cls, result):
  function on_plugin_start (line 127) | def on_plugin_start(config):
  function on_plugin_shutdown (line 142) | def on_plugin_shutdown(config):
  class DemoMailbox (line 157) | class DemoMailbox(object):
    method parse_path (line 160) | def parse_path(cls, config, fn, create=False):

FILE: shared-data/contrib/experiments/experiments.py
  function paragraph_id_extractor (line 12) | def paragraph_id_extractor(index, msg, ctype, textpart, **kwargs):

FILE: shared-data/contrib/forcegrapher/d3.drasl.js
  function d3_ascending (line 36) | function d3_ascending(a, b) {
  function d3_number (line 90) | function d3_number(x) {
  function d3_bisector (line 111) | function d3_bisector(compare) {
  function d3_zipLength (line 168) | function d3_zipLength(d) {
  function d3_range_integerScale (line 220) | function d3_range_integerScale(x) {
  function d3_class (line 225) | function d3_class(ctor, properties) {
  function d3_Map (line 244) | function d3_Map() {}
  function d3_map_has (line 279) | function d3_map_has(key) {
  function d3_map_remove (line 282) | function d3_map_remove(key) {
  function d3_map_keys (line 286) | function d3_map_keys() {
  function d3_map_size (line 293) | function d3_map_size() {
  function d3_map_empty (line 298) | function d3_map_empty() {
  function map (line 304) | function map(mapType, array, depth) {
  function entries (line 328) | function entries(map, depth) {
  function d3_Set (line 370) | function d3_Set() {}
  function d3_rebind (line 394) | function d3_rebind(target, source, method) {
  function d3_vendorSymbol (line 400) | function d3_vendorSymbol(object, name) {
  function d3_noop (line 409) | function d3_noop() {}
  function d3_dispatch (line 415) | function d3_dispatch() {}
  function d3_dispatch_event (line 430) | function d3_dispatch_event(dispatch) {
  function d3_eventPreventDefault (line 453) | function d3_eventPreventDefault() {
  function d3_eventSource (line 456) | function d3_eventSource() {
  function d3_eventDispatch (line 461) | function d3_eventDispatch(target) {
  function d3_selection (line 487) | function d3_selection(groups) {
  function d3_selection_selector (line 526) | function d3_selection_selector(selector) {
  function d3_selection_selectorAll (line 544) | function d3_selection_selectorAll(selector) {
  function d3_selection_attr (line 582) | function d3_selection_attr(name, value) {
  function d3_collapse (line 606) | function d3_collapse(s) {
  function d3_selection_classedRe (line 626) | function d3_selection_classedRe(name) {
  function d3_selection_classes (line 629) | function d3_selection_classes(name) {
  function d3_selection_classed (line 632) | function d3_selection_classed(name, value) {
  function d3_selection_classedName (line 645) | function d3_selection_classedName(name) {
  function d3_selection_style (line 671) | function d3_selection_style(name, value, priority) {
  function d3_selection_property (line 692) | function d3_selection_property(name, value) {
  function d3_selection_creator (line 731) | function d3_selection_creator(name) {
  function bind (line 762) | function bind(group, groupData) {
  function d3_selection_dataNode (line 833) | function d3_selection_dataNode(data) {
  function d3_selection_filter (line 855) | function d3_selection_filter(selector) {
  function d3_selection_sortComparator (line 876) | function d3_selection_sortComparator(comparator) {
  function d3_selection_each (line 887) | function d3_selection_each(groups, callback) {
  function d3_selection_enter (line 919) | function d3_selection_enter(selection) {
  function d3_selection_enterInsertBefore (line 952) | function d3_selection_enterInsertBefore(enter) {
  function d3_selection_interrupt (line 981) | function d3_selection_interrupt() {
  function d3_selection_on (line 1009) | function d3_selection_on(type, listener, capture) {
  function d3_selection_onListener (line 1046) | function d3_selection_onListener(listener, argumentz) {
  function d3_selection_onFilter (line 1058) | function d3_selection_onFilter(listener, argumentz) {
  function d3_event_dragSuppress (line 1068) | function d3_event_dragSuppress() {
  function d3_mousePoint (line 1092) | function d3_mousePoint(container, e) {
  function drag (line 1114) | function drag() {
  function dragstart (line 1117) | function dragstart(id, position, subject, move, end) {
  function d3_behavior_dragTouchId (line 1161) | function d3_behavior_dragTouchId() {
  function d3_behavior_dragTouchSubject (line 1164) | function d3_behavior_dragTouchSubject() {
  function d3_behavior_dragMouseSubject (line 1167) | function d3_behavior_dragMouseSubject() {
  function d3_sgn (line 1171) | function d3_sgn(x) {
  function d3_cross2d (line 1174) | function d3_cross2d(a, b, c) {
  function d3_acos (line 1177) | function d3_acos(x) {
  function d3_asin (line 1180) | function d3_asin(x) {
  function d3_sinh (line 1183) | function d3_sinh(x) {
  function d3_cosh (line 1186) | function d3_cosh(x) {
  function d3_tanh (line 1189) | function d3_tanh(x) {
  function d3_haversin (line 1192) | function d3_haversin(x) {
  function interpolate (line 1199) | function interpolate(t) {
  function zoom (line 1216) | function zoom(g) {
  function location (line 1309) | function location(p) {
  function point (line 1312) | function point(l) {
  function scaleTo (line 1315) | function scaleTo(s) {
  function translateTo (line 1318) | function translateTo(p, l) {
  function rescale (line 1323) | function rescale() {
  function zoomstarted (line 1331) | function zoomstarted(dispatch) {
  function zoomed (line 1336) | function zoomed(dispatch) {
  function zoomended (line 1344) | function zoomended(dispatch) {
  function mousedowned (line 1349) | function mousedowned() {
  function touchstarted (line 1364) | function touchstarted() {
  function mousewheeled (line 1432) | function mousewheeled() {
  function mousewheelreset (line 1447) | function mousewheelreset() {
  function dblclicked (line 1450) | function dblclicked() {
  function d3_Color (line 1468) | function d3_Color() {}
  function d3_hsl (line 1475) | function d3_hsl(h, s, l) {
  function d3_Hsl (line 1478) | function d3_Hsl(h, s, l) {
  function d3_hsl_rgb (line 1495) | function d3_hsl_rgb(h, s, l) {
  function d3_hcl (line 1517) | function d3_hcl(h, c, l) {
  function d3_Hcl (line 1520) | function d3_Hcl(h, c, l) {
  function d3_hcl_lab (line 1535) | function d3_hcl_lab(h, c, l) {
  function d3_lab (line 1543) | function d3_lab(l, a, b) {
  function d3_Lab (line 1546) | function d3_Lab(l, a, b) {
  function d3_lab_rgb (line 1563) | function d3_lab_rgb(l, a, b) {
  function d3_lab_hcl (line 1570) | function d3_lab_hcl(l, a, b) {
  function d3_lab_xyz (line 1573) | function d3_lab_xyz(x) {
  function d3_xyz_lab (line 1576) | function d3_xyz_lab(x) {
  function d3_xyz_rgb (line 1579) | function d3_xyz_rgb(r) {
  function d3_rgbNumber (line 1585) | function d3_rgbNumber(value) {
  function d3_rgbString (line 1588) | function d3_rgbString(value) {
  function d3_rgb (line 1591) | function d3_rgb(r, g, b) {
  function d3_Rgb (line 1594) | function d3_Rgb(r, g, b) {
  function d3_rgb_hex (line 1619) | function d3_rgb_hex(v) {
  function d3_rgb_parse (line 1622) | function d3_rgb_parse(format, rgb, hsl) {
  function d3_rgb_hsl (line 1656) | function d3_rgb_hsl(r, g, b) {
  function d3_rgb_lab (line 1668) | function d3_rgb_lab(r, g, b) {
  function d3_rgb_xyz (line 1675) | function d3_rgb_xyz(r) {
  function d3_rgb_parseNumber (line 1678) | function d3_rgb_parseNumber(c) {
  function d3_functor (line 1834) | function d3_functor(v) {
  function d3_identity (line 1840) | function d3_identity(d) {
  function d3_xhrType (line 1844) | function d3_xhrType(response) {
  function d3_xhr (line 1851) | function d3_xhr(url, mimeType, response, callback) {
  function d3_xhr_fixCallback (line 1926) | function d3_xhr_fixCallback(callback) {
  function dsv (line 1933) | function dsv(url, row, callback) {
  function response (line 1941) | function response(request) {
  function typedResponse (line 1944) | function typedResponse(f) {
  function token (line 1963) | function token() {
  function formatRow (line 2025) | function formatRow(row) {
  function formatValue (line 2028) | function formatValue(text) {
  function d3_timer_step (line 2064) | function d3_timer_step() {
  function d3_timer_mark (line 2081) | function d3_timer_mark() {
  function d3_timer_sweep (line 2090) | function d3_timer_sweep() {
  function d3_format_precision (line 2103) | function d3_format_precision(x, p) {
  function d3_formatPrefix (line 2120) | function d3_formatPrefix(d, i) {
  function d3_locale_numberFormat (line 2131) | function d3_locale_numberFormat(locale) {
  function d3_format_typeDefault (line 2242) | function d3_format_typeDefault(x) {
  function d3_date_utc (line 2246) | function d3_date_utc() {
  function d3_time_interval (line 2312) | function d3_time_interval(local, step, number) {
  function d3_time_interval_utc (line 2360) | function d3_time_interval_utc(method) {
  function d3_locale_timeFormat (line 2420) | function d3_locale_timeFormat(locale) {
  function d3_time_formatPad (line 2640) | function d3_time_formatPad(value, fill, width) {
  function d3_time_formatRe (line 2644) | function d3_time_formatRe(names) {
  function d3_time_formatLookup (line 2647) | function d3_time_formatLookup(names) {
  function d3_time_parseWeekdayNumber (line 2652) | function d3_time_parseWeekdayNumber(date, string, i) {
  function d3_time_parseWeekNumberSunday (line 2657) | function d3_time_parseWeekNumberSunday(date, string, i) {
  function d3_time_parseWeekNumberMonday (line 2662) | function d3_time_parseWeekNumberMonday(date, string, i) {
  function d3_time_parseFullYear (line 2667) | function d3_time_parseFullYear(date, string, i) {
  function d3_time_parseYear (line 2672) | function d3_time_parseYear(date, string, i) {
  function d3_time_parseZone (line 2677) | function d3_time_parseZone(date, string, i) {
  function d3_time_expandYear (line 2681) | function d3_time_expandYear(d) {
  function d3_time_parseMonthNumber (line 2684) | function d3_time_parseMonthNumber(date, string, i) {
  function d3_time_parseDay (line 2689) | function d3_time_parseDay(date, string, i) {
  function d3_time_parseDayOfYear (line 2694) | function d3_time_parseDayOfYear(date, string, i) {
  function d3_time_parseHour24 (line 2699) | function d3_time_parseHour24(date, string, i) {
  function d3_time_parseMinutes (line 2704) | function d3_time_parseMinutes(date, string, i) {
  function d3_time_parseSeconds (line 2709) | function d3_time_parseSeconds(date, string, i) {
  function d3_time_parseMilliseconds (line 2714) | function d3_time_parseMilliseconds(date, string, i) {
  function d3_time_zone (line 2719) | function d3_time_zone(d) {
  function d3_time_parseLiteralPercent (line 2723) | function d3_time_parseLiteralPercent(date, string, i) {
  function d3_time_formatMulti (line 2728) | function d3_time_formatMulti(formats) {
  function d3_adder (line 2759) | function d3_adder() {}
  function d3_adderSum (line 2776) | function d3_adderSum(a, b, o) {
  function d3_geo_streamGeometry (line 2787) | function d3_geo_streamGeometry(geometry, listener) {
  function d3_geo_streamLine (line 2832) | function d3_geo_streamLine(coordinates, listener, closed) {
  function d3_geo_streamPolygon (line 2838) | function d3_geo_streamPolygon(coordinates, listener) {
  function d3_geo_areaRingStart (line 2867) | function d3_geo_areaRingStart() {
  function d3_geo_cartesian (line 2885) | function d3_geo_cartesian(spherical) {
  function d3_geo_cartesianDot (line 2889) | function d3_geo_cartesianDot(a, b) {
  function d3_geo_cartesianCross (line 2892) | function d3_geo_cartesianCross(a, b) {
  function d3_geo_cartesianAdd (line 2895) | function d3_geo_cartesianAdd(a, b) {
  function d3_geo_cartesianScale (line 2900) | function d3_geo_cartesianScale(vector, k) {
  function d3_geo_cartesianNormalize (line 2903) | function d3_geo_cartesianNormalize(d) {
  function d3_geo_spherical (line 2909) | function d3_geo_spherical(cartesian) {
  function d3_geo_sphericalEqual (line 2912) | function d3_geo_sphericalEqual(a, b) {
  function point (line 2937) | function point(λ, φ) {
  function linePoint (line 2942) | function linePoint(λ, φ) {
  function lineStart (line 2982) | function lineStart() {
  function lineEnd (line 2985) | function lineEnd() {
  function ringPoint (line 2990) | function ringPoint(λ, φ) {
  function ringStart (line 2998) | function ringStart() {
  function ringEnd (line 3001) | function ringEnd() {
  function angle (line 3008) | function angle(λ0, λ1) {
  function compareRanges (line 3011) | function compareRanges(a, b) {
  function withinRange (line 3014) | function withinRange(x, range) {
  function d3_geo_centroidPoint (line 3068) | function d3_geo_centroidPoint(λ, φ) {
  function d3_geo_centroidPointXYZ (line 3073) | function d3_geo_centroidPointXYZ(x, y, z) {
  function d3_geo_centroidLineStart (line 3079) | function d3_geo_centroidLineStart() {
  function d3_geo_centroidLineEnd (line 3100) | function d3_geo_centroidLineEnd() {
  function d3_geo_centroidRingStart (line 3103) | function d3_geo_centroidRingStart() {
  function d3_true (line 3133) | function d3_true() {
  function d3_geo_clipPolygon (line 3136) | function d3_geo_clipPolygon(segments, compare, clipStartInside, interpol...
  function d3_geo_clipPolygonLinkCircular (line 3195) | function d3_geo_clipPolygonLinkCircular(array) {
  function d3_geo_clipPolygonIntersection (line 3206) | function d3_geo_clipPolygonIntersection(point, points, other, entry) {
  function d3_geo_clip (line 3214) | function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
  function d3_geo_clipSegmentLength1 (line 3306) | function d3_geo_clipSegmentLength1(segment) {
  function d3_geo_clipBufferListener (line 3309) | function d3_geo_clipBufferListener() {
  function d3_geo_clipSort (line 3330) | function d3_geo_clipSort(a, b) {
  function d3_geo_pointInPolygon (line 3333) | function d3_geo_pointInPolygon(point, polygon) {
  function d3_geo_clipAntimeridianLine (line 3363) | function d3_geo_clipAntimeridianLine(listener) {
  function d3_geo_clipAntimeridianIntersect (line 3402) | function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
  function d3_geo_clipAntimeridianInterpolate (line 3406) | function d3_geo_clipAntimeridianInterpolate(from, to, direction, listene...
  function d3_geo_clipCircle (line 3429) | function d3_geo_clipCircle(radius) {
  function d3_geom_clipLine (line 3525) | function d3_geom_clipLine(x0, y0, x1, y1) {
  function d3_geo_clipExtent (line 3597) | function d3_geo_clipExtent(x0, y0, x1, y1) {
  function d3_geo_compose (line 3731) | function d3_geo_compose(a, b) {
  function d3_geo_conic (line 3740) | function d3_geo_conic(projectAt) {
  function d3_geo_conicEqualArea (line 3748) | function d3_geo_conicEqualArea(φ0, φ1) {
  function albersUsa (line 3775) | function albersUsa(coordinates) {
  function d3_geo_pathAreaRingStart (line 3857) | function d3_geo_pathAreaRingStart() {
  function d3_geo_pathBoundsPoint (line 3879) | function d3_geo_pathBoundsPoint(x, y) {
  function d3_geo_pathBuffer (line 3885) | function d3_geo_pathBuffer() {
  function d3_geo_pathBufferCircle (line 3930) | function d3_geo_pathBufferCircle(radius) {
  function d3_geo_pathCentroidPoint (line 3946) | function d3_geo_pathCentroidPoint(x, y) {
  function d3_geo_pathCentroidLineStart (line 3951) | function d3_geo_pathCentroidLineStart() {
  function d3_geo_pathCentroidLineEnd (line 3965) | function d3_geo_pathCentroidLineEnd() {
  function d3_geo_pathCentroidRingStart (line 3968) | function d3_geo_pathCentroidRingStart() {
  function d3_geo_pathContext (line 3989) | function d3_geo_pathContext(context) {
  function d3_geo_resample (line 4029) | function d3_geo_resample(project) {
  function path (line 4109) | function path(object) {
  function reset (line 4148) | function reset() {
  function d3_geo_pathProjectStream (line 4154) | function d3_geo_pathProjectStream(project) {
  function d3_geo_transform (line 4171) | function d3_geo_transform(stream) {
  function d3_geo_transformPoint (line 4194) | function d3_geo_transformPoint(stream, point) {
  function d3_geo_projection (line 4216) | function d3_geo_projection(project) {
  function d3_geo_projectionMutator (line 4221) | function d3_geo_projectionMutator(projectAt) {
  function d3_geo_projectionRadians (line 4293) | function d3_geo_projectionRadians(stream) {
  function d3_geo_equirectangular (line 4298) | function d3_geo_equirectangular(λ, φ) {
  function forward (line 4306) | function forward(coordinates) {
  function d3_geo_identityRotation (line 4316) | function d3_geo_identityRotation(λ, φ) {
  function d3_geo_rotation (line 4320) | function d3_geo_rotation(δλ, δφ, δγ) {
  function d3_geo_forwardRotationλ (line 4323) | function d3_geo_forwardRotationλ(δλ) {
  function d3_geo_rotationλ (line 4328) | function d3_geo_rotationλ(δλ) {
  function d3_geo_rotationφγ (line 4333) | function d3_geo_rotationφγ(δφ, δγ) {
  function circle (line 4347) | function circle() {
  function d3_geo_circleInterpolate (line 4377) | function d3_geo_circleInterpolate(radius, precision) {
  function d3_geo_circleAngle (line 4394) | function d3_geo_circleAngle(cr, point) {
  function graticule (line 4407) | function graticule() {
  function lines (line 4413) | function lines() {
  function d3_geo_graticuleX (line 4479) | function d3_geo_graticuleX(y0, y1, dy) {
  function d3_geo_graticuleY (line 4487) | function d3_geo_graticuleY(x0, x1, dx) {
  function d3_source (line 4495) | function d3_source(d) {
  function d3_target (line 4498) | function d3_target(d) {
  function greatArc (line 4503) | function greatArc() {
  function d3_geo_interpolate (line 4530) | function d3_geo_interpolate(x0, y0, x1, y1) {
  function d3_geo_lengthLineStart (line 4555) | function d3_geo_lengthLineStart() {
  function d3_geo_azimuthal (line 4570) | function d3_geo_azimuthal(scale, angle) {
  function d3_geo_conicConformal (line 4596) | function d3_geo_conicConformal(φ0, φ1) {
  function d3_geo_conicEquidistant (line 4619) | function d3_geo_conicEquidistant(φ0, φ1) {
  function d3_geo_mercator (line 4641) | function d3_geo_mercator(λ, φ) {
  function d3_geo_mercatorProjection (line 4647) | function d3_geo_mercatorProjection(project) {
  function d3_geo_transverseMercator (line 4688) | function d3_geo_transverseMercator(λ, φ) {
  function d3_geom_pointX (line 4706) | function d3_geom_pointX(d) {
  function d3_geom_pointY (line 4709) | function d3_geom_pointY(d) {
  function hull (line 4715) | function hull(data) {
  function d3_geom_hullUpper (line 4737) | function d3_geom_hullUpper(points) {
  function d3_geom_hullOrder (line 4745) | function d3_geom_hullOrder(a, b) {
  function d3_geom_polygonInside (line 4799) | function d3_geom_polygonInside(p, a, b) {
  function d3_geom_polygonIntersect (line 4802) | function d3_geom_polygonIntersect(c, d, a, b) {
  function d3_geom_polygonClosed (line 4806) | function d3_geom_polygonClosed(coordinates) {
  function d3_geom_voronoiBeach (line 4811) | function d3_geom_voronoiBeach() {
  function d3_geom_voronoiCreateBeach (line 4815) | function d3_geom_voronoiCreateBeach(site) {
  function d3_geom_voronoiDetachBeach (line 4820) | function d3_geom_voronoiDetachBeach(beach) {
  function d3_geom_voronoiRemoveBeach (line 4826) | function d3_geom_voronoiRemoveBeach(beach) {
  function d3_geom_voronoiAddBeach (line 4862) | function d3_geom_voronoiAddBeach(site) {
  function d3_geom_voronoiLeftBreakPoint (line 4916) | function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
  function d3_geom_voronoiRightBreakPoint (line 4928) | function d3_geom_voronoiRightBreakPoint(arc, directrix) {
  function d3_geom_voronoiCell (line 4934) | function d3_geom_voronoiCell(site) {
  function d3_geom_voronoiCloseCells (line 4947) | function d3_geom_voronoiCloseCells(extent) {
  function d3_geom_voronoiHalfEdgeOrder (line 4977) | function d3_geom_voronoiHalfEdgeOrder(a, b) {
  function d3_geom_voronoiCircle (line 4980) | function d3_geom_voronoiCircle() {
  function d3_geom_voronoiAttachCircle (line 4984) | function d3_geom_voronoiAttachCircle(arc) {
  function d3_geom_voronoiDetachCircle (line 5017) | function d3_geom_voronoiDetachCircle(arc) {
  function d3_geom_voronoiClipEdges (line 5027) | function d3_geom_voronoiClipEdges(extent) {
  function d3_geom_voronoiConnectEdge (line 5037) | function d3_geom_voronoiConnectEdge(edge, extent) {
  function d3_geom_voronoiEdge (line 5111) | function d3_geom_voronoiEdge(lSite, rSite) {
  function d3_geom_voronoiCreateEdge (line 5116) | function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
  function d3_geom_voronoiCreateBorderEdge (line 5125) | function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
  function d3_geom_voronoiSetEdgeEnd (line 5132) | function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
  function d3_geom_voronoiHalfEdge (line 5143) | function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
  function d3_geom_voronoiRedBlackTree (line 5157) | function d3_geom_voronoiRedBlackTree() {
  function d3_geom_voronoiRedBlackNode (line 5160) | function d3_geom_voronoiRedBlackNode(node) {
  function d3_geom_voronoiRedBlackRotateLeft (line 5323) | function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
  function d3_geom_voronoiRedBlackRotateRight (line 5336) | function d3_geom_voronoiRedBlackRotateRight(tree, node) {
  function d3_geom_voronoiRedBlackFirst (line 5349) | function d3_geom_voronoiRedBlackFirst(node) {
  function d3_geom_voronoi (line 5353) | function d3_geom_voronoi(sites, bbox) {
  function d3_geom_voronoiVertexOrder (line 5382) | function d3_geom_voronoiVertexOrder(a, b) {
  function voronoi (line 5388) | function voronoi(data) {
  function sites (line 5399) | function sites(data) {
  function d3_geom_voronoiTriangleArea (line 5452) | function d3_geom_voronoiTriangleArea(a, b, c) {
  function quadtree (line 5470) | function quadtree(data) {
  function d3_geom_quadtreeCompatX (line 5562) | function d3_geom_quadtreeCompatX(d) {
  function d3_geom_quadtreeCompatY (line 5565) | function d3_geom_quadtreeCompatY(d) {
  function d3_geom_quadtreeNode (line 5568) | function d3_geom_quadtreeNode() {
  function d3_geom_quadtreeVisit (line 5577) | function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
  function d3_interpolateRgb (line 5587) | function d3_interpolateRgb(a, b) {
  function d3_interpolateObject (line 5596) | function d3_interpolateObject(a, b) {
  function d3_interpolateNumber (line 5616) | function d3_interpolateNumber(a, b) {
  function d3_interpolateString (line 5623) | function d3_interpolateString(a, b) {
  function d3_interpolate (line 5657) | function d3_interpolate(a, b) {
  function d3_interpolateArray (line 5667) | function d3_interpolateArray(a, b) {
  function d3_ease_clamp (line 5718) | function d3_ease_clamp(f) {
  function d3_ease_reverse (line 5723) | function d3_ease_reverse(f) {
  function d3_ease_reflect (line 5728) | function d3_ease_reflect(f) {
  function d3_ease_quad (line 5733) | function d3_ease_quad(t) {
  function d3_ease_cubic (line 5736) | function d3_ease_cubic(t) {
  function d3_ease_cubicInOut (line 5739) | function d3_ease_cubicInOut(t) {
  function d3_ease_poly (line 5745) | function d3_ease_poly(e) {
  function d3_ease_sin (line 5750) | function d3_ease_sin(t) {
  function d3_ease_exp (line 5753) | function d3_ease_exp(t) {
  function d3_ease_circle (line 5756) | function d3_ease_circle(t) {
  function d3_ease_elastic (line 5759) | function d3_ease_elastic(a, p) {
  function d3_ease_back (line 5767) | function d3_ease_back(s) {
  function d3_ease_bounce (line 5773) | function d3_ease_bounce(t) {
  function d3_interpolateHcl (line 5777) | function d3_interpolateHcl(a, b) {
  function d3_interpolateHsl (line 5788) | function d3_interpolateHsl(a, b) {
  function d3_interpolateLab (line 5799) | function d3_interpolateLab(a, b) {
  function d3_interpolateRound (line 5808) | function d3_interpolateRound(a, b) {
  function d3_transform (line 5824) | function d3_transform(m) {
  function d3_transformDot (line 5840) | function d3_transformDot(a, b) {
  function d3_transformNormalize (line 5843) | function d3_transformNormalize(a) {
  function d3_transformCombine (line 5851) | function d3_transformCombine(a, b, k) {
  function d3_interpolateTransform (line 5865) | function d3_interpolateTransform(a, b) {
  function d3_uninterpolateNumber (line 5917) | function d3_uninterpolateNumber(a, b) {
  function d3_uninterpolateClamp (line 5923) | function d3_uninterpolateClamp(a, b) {
  function d3_layout_bundlePath (line 5937) | function d3_layout_bundlePath(link) {
  function d3_layout_bundleAncestors (line 5950) | function d3_layout_bundleAncestors(node) {
  function d3_layout_bundleLeastCommonAncestor (line 5960) | function d3_layout_bundleLeastCommonAncestor(a, b) {
  function relayout (line 5972) | function relayout() {
  function resort (line 6038) | function resort() {
  function repulse (line 6085) | function repulse(node) {
  function position (line 6257) | function position(dimension, size) {
  function dragmove (line 6286) | function dragmove(d) {
  function d3_layout_forceDragstart (line 6292) | function d3_layout_forceDragstart(d) {
  function d3_layout_forceDragend (line 6295) | function d3_layout_forceDragend(d) {
  function d3_layout_forceMouseover (line 6298) | function d3_layout_forceMouseover(d) {
  function d3_layout_forceMouseout (line 6302) | function d3_layout_forceMouseout(d) {
  function d3_layout_forceAccumulate (line 6305) | function d3_layout_forceAccumulate(quad, alpha, charges) {
  function recurse (line 6335) | function recurse(node, depth, nodes) {
  function revalue (line 6356) | function revalue(node, depth) {
  function hierarchy (line 6367) | function hierarchy(d) {
  function d3_layout_hierarchyRebind (line 6393) | function d3_layout_hierarchyRebind(object, hierarchy) {
  function d3_layout_hierarchyChildren (line 6399) | function d3_layout_hierarchyChildren(d) {
  function d3_layout_hierarchyValue (line 6402) | function d3_layout_hierarchyValue(d) {
  function d3_layout_hierarchySort (line 6405) | function d3_layout_hierarchySort(a, b) {
  function d3_layout_hierarchyLinks (line 6408) | function d3_layout_hierarchyLinks(nodes) {
  function position (line 6420) | function position(node, x, dx, dy) {
  function depth (line 6435) | function depth(node) {
  function partition (line 6443) | function partition(d, i) {
  function pie (line 6457) | function pie(data) {
  function stack (line 6506) | function stack(data, index) {
  function d3_layout_stackX (line 6560) | function d3_layout_stackX(d) {
  function d3_layout_stackY (line 6563) | function d3_layout_stackY(d) {
  function d3_layout_stackOut (line 6566) | function d3_layout_stackOut(d, y0, y) {
  function d3_layout_stackOrderDefault (line 6633) | function d3_layout_stackOrderDefault(data) {
  function d3_layout_stackOffsetZero (line 6636) | function d3_layout_stackOffsetZero(data) {
  function d3_layout_stackMaxIndex (line 6641) | function d3_layout_stackMaxIndex(array) {
  function d3_layout_stackReduceSum (line 6651) | function d3_layout_stackReduceSum(d) {
  function d3_layout_stackSum (line 6654) | function d3_layout_stackSum(p, d) {
  function histogram (line 6659) | function histogram(data, i) {
  function d3_layout_histogramBinSturges (line 6703) | function d3_layout_histogramBinSturges(range, values) {
  function d3_layout_histogramBinFixed (line 6706) | function d3_layout_histogramBinFixed(range, n) {
  function d3_layout_histogramRange (line 6711) | function d3_layout_histogramRange(values) {
  function tree (line 6716) | function tree(d, i) {
  function d3_layout_treeSeparation (line 6824) | function d3_layout_treeSeparation(a, b) {
  function d3_layout_treeLeft (line 6827) | function d3_layout_treeLeft(node) {
  function d3_layout_treeRight (line 6831) | function d3_layout_treeRight(node) {
  function d3_layout_treeSearch (line 6835) | function d3_layout_treeSearch(node, compare) {
  function d3_layout_treeRightmost (line 6847) | function d3_layout_treeRightmost(a, b) {
  function d3_layout_treeLeftmost (line 6850) | function d3_layout_treeLeftmost(a, b) {
  function d3_layout_treeDeepest (line 6853) | function d3_layout_treeDeepest(a, b) {
  function d3_layout_treeVisitAfter (line 6856) | function d3_layout_treeVisitAfter(node, callback) {
  function d3_layout_treeShift (line 6871) | function d3_layout_treeShift(node) {
  function d3_layout_treeMove (line 6880) | function d3_layout_treeMove(ancestor, node, shift) {
  function d3_layout_treeAncestor (line 6890) | function d3_layout_treeAncestor(vim, node, ancestor) {
  function pack (line 6895) | function pack(d, i) {
  function d3_layout_packSort (line 6934) | function d3_layout_packSort(a, b) {
  function d3_layout_packInsert (line 6937) | function d3_layout_packInsert(a, b) {
  function d3_layout_packSplice (line 6944) | function d3_layout_packSplice(a, b) {
  function d3_layout_packIntersects (line 6948) | function d3_layout_packIntersects(a, b) {
  function d3_layout_packSiblings (line 6952) | function d3_layout_packSiblings(node) {
  function d3_layout_packLink (line 7016) | function d3_layout_packLink(node) {
  function d3_layout_packUnlink (line 7019) | function d3_layout_packUnlink(node) {
  function d3_layout_packTransform (line 7023) | function d3_layout_packTransform(node, x, y, k) {
  function d3_layout_packPlace (line 7033) | function d3_layout_packPlace(a, b, c) {
  function cluster (line 7049) | function cluster(d, i) {
  function d3_layout_clusterY (line 7089) | function d3_layout_clusterY(children) {
  function d3_layout_clusterX (line 7094) | function d3_layout_clusterX(children) {
  function d3_layout_clusterLeft (line 7099) | function d3_layout_clusterLeft(node) {
  function d3_layout_clusterRight (line 7103) | function d3_layout_clusterRight(node) {
  function scale (line 7109) | function scale(children, k) {
  function squarify (line 7116) | function squarify(node) {
  function stickify (line 7143) | function stickify(node) {
  function worst (line 7160) | function worst(row, u) {
  function position (line 7171) | function position(row, u, rect, flush) {
  function treemap (line 7201) | function treemap(d) {
  function padFunction (line 7220) | function padFunction(node) {
  function padConstant (line 7224) | function padConstant(node) {
  function d3_layout_treemapPadNull (line 7255) | function d3_layout_treemapPadNull(node) {
  function d3_layout_treemapPad (line 7263) | function d3_layout_treemapPad(node, padding) {
  function d3_scaleExtent (line 7315) | function d3_scaleExtent(domain) {
  function d3_scaleRange (line 7319) | function d3_scaleRange(scale) {
  function d3_scale_bilinear (line 7322) | function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
  function d3_scale_nice (line 7328) | function d3_scale_nice(domain, nice) {
  function d3_scale_niceStep (line 7338) | function d3_scale_niceStep(step) {
  function d3_scale_polylinear (line 7352) | function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
  function d3_scale_linear (line 7370) | function d3_scale_linear(domain, range, interpolate, clamp) {
  function d3_scale_linearRebind (line 7422) | function d3_scale_linearRebind(scale, linear) {
  function d3_scale_linearNice (line 7425) | function d3_scale_linearNice(domain, m) {
  function d3_scale_linearTickRange (line 7428) | function d3_scale_linearTickRange(domain, m) {
  function d3_scale_linearTicks (line 7437) | function d3_scale_linearTicks(domain, m) {
  function d3_scale_linearTickFormat (line 7440) | function d3_scale_linearTickFormat(domain, m, format) {
  function d3_scale_linearPrecision (line 7468) | function d3_scale_linearPrecision(value) {
  function d3_scale_linearFormatPrecision (line 7471) | function d3_scale_linearFormatPrecision(type, range) {
  function d3_scale_log (line 7478) | function d3_scale_log(linear, base, positive, domain) {
  function d3_scale_pow (line 7550) | function d3_scale_pow(linear, exponent, domain) {
  function d3_scale_powPow (line 7584) | function d3_scale_powPow(e) {
  function d3_scale_ordinal (line 7598) | function d3_scale_ordinal(domain, ranger) {
  function d3_scale_quantile (line 7693) | function d3_scale_quantile(domain, range) {
  function d3_scale_quantize (line 7729) | function d3_scale_quantize(x0, x1, range) {
  function d3_scale_threshold (line 7763) | function d3_scale_threshold(domain, range) {
  function d3_scale_identity (line 7789) | function d3_scale_identity(domain) {
  function arc (line 7813) | function arc() {
  function d3_svg_arcInnerRadius (line 7845) | function d3_svg_arcInnerRadius(d) {
  function d3_svg_arcOuterRadius (line 7848) | function d3_svg_arcOuterRadius(d) {
  function d3_svg_arcStartAngle (line 7851) | function d3_svg_arcStartAngle(d) {
  function d3_svg_arcEndAngle (line 7854) | function d3_svg_arcEndAngle(d) {
  function d3_svg_line (line 7857) | function d3_svg_line(projection) {
  function d3_svg_lineLinear (line 7924) | function d3_svg_lineLinear(points) {
  function d3_svg_lineLinearClosed (line 7927) | function d3_svg_lineLinearClosed(points) {
  function d3_svg_lineStep (line 7930) | function d3_svg_lineStep(points) {
  function d3_svg_lineStepBefore (line 7936) | function d3_svg_lineStepBefore(points) {
  function d3_svg_lineStepAfter (line 7941) | function d3_svg_lineStepAfter(points) {
  function d3_svg_lineCardinalOpen (line 7946) | function d3_svg_lineCardinalOpen(points, tension) {
  function d3_svg_lineCardinalClosed (line 7949) | function d3_svg_lineCardinalClosed(points, tension) {
  function d3_svg_lineCardinal (line 7953) | function d3_svg_lineCardinal(points, tension) {
  function d3_svg_lineHermite (line 7956) | function d3_svg_lineHermite(points, tangents) {
  function d3_svg_lineCardinalTangents (line 7983) | function d3_svg_lineCardinalTangents(points, tension) {
  function d3_svg_lineBasis (line 7993) | function d3_svg_lineBasis(points) {
  function d3_svg_lineBasisOpen (line 8009) | function d3_svg_lineBasisOpen(points) {
  function d3_svg_lineBasisClosed (line 8029) | function d3_svg_lineBasisClosed(points) {
  function d3_svg_lineBundle (line 8048) | function d3_svg_lineBundle(points, tension) {
  function d3_svg_lineDot4 (line 8061) | function d3_svg_lineDot4(a, b) {
  function d3_svg_lineBasisBezier (line 8065) | function d3_svg_lineBasisBezier(path, x, y) {
  function d3_svg_lineSlope (line 8068) | function d3_svg_lineSlope(p0, p1) {
  function d3_svg_lineFiniteDifferences (line 8071) | function d3_svg_lineFiniteDifferences(points) {
  function d3_svg_lineMonotoneTangents (line 8079) | function d3_svg_lineMonotoneTangents(points) {
  function d3_svg_lineMonotone (line 8103) | function d3_svg_lineMonotone(points) {
  function d3_svg_lineRadial (line 8112) | function d3_svg_lineRadial(points) {
  function d3_svg_area (line 8123) | function d3_svg_area(projection) {
  function chord (line 8213) | function chord(d, i) {
  function subgroup (line 8217) | function subgroup(self, f, d, i) {
  function equals (line 8227) | function equals(a, b) {
  function arc (line 8230) | function arc(r, p, a) {
  function curve (line 8233) | function curve(r0, p0, r1, p1) {
  function d3_svg_chordRadius (line 8263) | function d3_svg_chordRadius(d) {
  function diagonal (line 8268) | function diagonal(d, i) {
  function d3_svg_diagonalProjection (line 8296) | function d3_svg_diagonalProjection(d) {
  function d3_svg_diagonalRadialProjection (line 8306) | function d3_svg_diagonalRadialProjection(projection) {
  function symbol (line 8314) | function symbol(d, i) {
  function d3_svg_symbolSize (line 8329) | function d3_svg_symbolSize() {
  function d3_svg_symbolType (line 8332) | function d3_svg_symbolType() {
  function d3_svg_symbolCircle (line 8335) | function d3_svg_symbolCircle(size) {
  function d3_transition (line 8364) | function d3_transition(groups, id) {
  function d3_transition_tween (line 8435) | function d3_transition_tween(groups, name, value, tween) {
  function attrNull (line 8449) | function attrNull() {
  function attrNullNS (line 8452) | function attrNullNS() {
  function attrTween (line 8455) | function attrTween(b) {
  function attrTweenNS (line 8463) | function attrTweenNS(b) {
  function attrTween (line 8475) | function attrTween(d, i) {
  function attrTweenNS (line 8481) | function attrTweenNS(d, i) {
  function styleNull (line 8499) | function styleNull() {
  function styleString (line 8502) | function styleString(b) {
  function styleTween (line 8514) | function styleTween(d, i) {
  function d3_transition_text (line 8525) | function d3_transition_text(b) {
  function d3_transitionNode (line 8597) | function d3_transitionNode(node, i, id, inherit) {
  function axis (line 8651) | function axis(g) {
  function d3_svg_axisX (line 8782) | function d3_svg_axisX(selection, x) {
  function d3_svg_axisY (line 8787) | function d3_svg_axisY(selection, y) {
  function brush (line 8794) | function brush(g) {
  function redraw (line 8880) | function redraw(g) {
  function redrawX (line 8885) | function redrawX(g) {
  function redrawY (line 8889) | function redrawY(g) {
  function brushstart (line 8893) | function brushstart() {
  function d3_time_formatIsoNative (line 9086) | function d3_time_formatIsoNative(date) {
  function d3_time_scale (line 9133) | function d3_time_scale(linear, methods, format) {
  function d3_time_scaleDate (line 9183) | function d3_time_scaleDate(t) {
  function d3_json (line 9242) | function d3_json(request) {
  function d3_html (line 9248) | function d3_html(request) {

FILE: shared-data/contrib/forcegrapher/d3.js
  function n (line 1) | function n(n,t){return t>n?-1:n>t?1:n>=t?0:0/0}
  function t (line 1) | function t(n){return null!=n&&!isNaN(n)}
  function e (line 1) | function e(n){return{left:function(t,e,r,u){for(arguments.length<3&&(r=0...
  function r (line 1) | function r(n){return n.length}
  function u (line 1) | function u(n){for(var t=1;n*t%1;)t*=10;return t}
  function i (line 1) | function i(n,t){try{for(var e in t)Object.defineProperty(n.prototype,e,{...
  function o (line 1) | function o(){}
  function a (line 1) | function a(n){return ha+n in this}
  function c (line 1) | function c(n){return n=ha+n,n in this&&delete this[n]}
  function s (line 1) | function s(){var n=[];return this.forEach(function(t){n.push(t)}),n}
  function l (line 1) | function l(){var n=0;for(var t in this)t.charCodeAt(0)===ga&&++n;return n}
  function f (line 1) | function f(){for(var n in this)if(n.charCodeAt(0)===ga)return!1;return!0}
  function h (line 1) | function h(){}
  function g (line 1) | function g(n,t,e){return function(){var r=e.apply(t,arguments);return r=...
  function p (line 1) | function p(n,t){if(t in n)return t;t=t.charAt(0).toUpperCase()+t.substri...
  function v (line 1) | function v(){}
  function d (line 1) | function d(){}
  function m (line 1) | function m(n){function t(){for(var t,r=e,u=-1,i=r.length;++u<i;)(t=r[u]....
  function y (line 1) | function y(){Go.event.preventDefault()}
  function x (line 1) | function x(){for(var n,t=Go.event;n=t.sourceEvent;)t=n;return t}
  function M (line 1) | function M(n){for(var t=new d,e=0,r=arguments.length;++e<r;)t[arguments[...
  function _ (line 1) | function _(n){return da(n,_a),n}
  function b (line 1) | function b(n){return"function"==typeof n?n:function(){return ma(n,this)}}
  function w (line 1) | function w(n){return"function"==typeof n?n:function(){return ya(n,this)}}
  function S (line 1) | function S(n,t){function e(){this.removeAttribute(n)}function r(){this.r...
  function k (line 1) | function k(n){return n.trim().replace(/\s+/g," ")}
  function E (line 1) | function E(n){return new RegExp("(?:^|\\s+)"+Go.requote(n)+"(?:\\s+|$)",...
  function A (line 1) | function A(n){return n.trim().split(/^|\s+/)}
  function C (line 1) | function C(n,t){function e(){for(var e=-1;++e<u;)n[e](this,t)}function r...
  function N (line 1) | function N(n){var t=E(n);return function(e,r){if(u=e.classList)return r?...
  function L (line 1) | function L(n,t,e){function r(){this.style.removeProperty(n)}function u()...
  function T (line 1) | function T(n,t){function e(){delete this[n]}function r(){this[n]=t}funct...
  function q (line 1) | function q(n){return"function"==typeof n?n:(n=Go.ns.qualify(n)).local?fu...
  function z (line 1) | function z(n){return{__data__:n}}
  function R (line 1) | function R(n){return function(){return Ma(this,n)}}
  function D (line 1) | function D(t){return arguments.length||(t=n),function(n,e){return n&&e?t...
  function P (line 1) | function P(n,t){for(var e=0,r=n.length;r>e;e++)for(var u,i=n[e],o=0,a=i....
  function U (line 1) | function U(n){return da(n,wa),n}
  function j (line 1) | function j(n){var t,e;return function(r,u,i){var o,a=n[i].update,c=a.len...
  function H (line 1) | function H(){var n=this.__transition__;n&&++n.active}
  function F (line 1) | function F(n,t,e){function r(){var t=this[o];t&&(this.removeEventListene...
  function O (line 1) | function O(n,t){return function(e){var r=Go.event;Go.event=e,t[0]=this._...
  function I (line 1) | function I(n,t){var e=O(n,t);return function(n){var t=this,r=n.relatedTa...
  function Y (line 1) | function Y(){var n=".dragsuppress-"+ ++Aa,t="click"+n,e=Go.select(ea).on...
  function Z (line 1) | function Z(n,t){t.changedTouches&&(t=t.changedTouches[0]);var e=n.ownerS...
  function V (line 1) | function V(){return Go.event.changedTouches[0].identifier}
  function $ (line 1) | function $(){return Go.event.target}
  function X (line 1) | function X(){return ea}
  function B (line 1) | function B(n){return n>0?1:0>n?-1:0}
  function J (line 1) | function J(n,t,e){return(t[0]-n[0])*(e[1]-n[1])-(t[1]-n[1])*(e[0]-n[0])}
  function W (line 1) | function W(n){return n>1?0:-1>n?Ca:Math.acos(n)}
  function G (line 1) | function G(n){return n>1?La:-1>n?-La:Math.asin(n)}
  function K (line 1) | function K(n){return((n=Math.exp(n))-1/n)/2}
  function Q (line 1) | function Q(n){return((n=Math.exp(n))+1/n)/2}
  function nt (line 1) | function nt(n){return((n=Math.exp(2*n))-1)/(n+1)}
  function tt (line 1) | function tt(n){return(n=Math.sin(n/2))*n}
  function et (line 1) | function et(){}
  function rt (line 1) | function rt(n,t,e){return new ut(n,t,e)}
  function ut (line 1) | function ut(n,t,e){this.h=n,this.s=t,this.l=e}
  function it (line 1) | function it(n,t,e){function r(n){return n>360?n-=360:0>n&&(n+=360),60>n?...
  function ot (line 1) | function ot(n,t,e){return new at(n,t,e)}
  function at (line 1) | function at(n,t,e){this.h=n,this.c=t,this.l=e}
  function ct (line 1) | function ct(n,t,e){return isNaN(n)&&(n=0),isNaN(t)&&(t=0),st(e,Math.cos(...
  function st (line 1) | function st(n,t,e){return new lt(n,t,e)}
  function lt (line 1) | function lt(n,t,e){this.l=n,this.a=t,this.b=e}
  function ft (line 1) | function ft(n,t,e){var r=(n+16)/116,u=r+t/500,i=r-e/200;return u=gt(u)*Z...
  function ht (line 1) | function ht(n,t,e){return n>0?ot(Math.atan2(e,t)*Ra,Math.sqrt(t*t+e*e),n...
  function gt (line 1) | function gt(n){return n>.206893034?n*n*n:(n-4/29)/7.787037}
  function pt (line 1) | function pt(n){return n>.008856?Math.pow(n,1/3):7.787037*n+4/29}
  function vt (line 1) | function vt(n){return Math.round(255*(.00304>=n?12.92*n:1.055*Math.pow(n...
  function dt (line 1) | function dt(n){return yt(n>>16,255&n>>8,255&n)}
  function mt (line 1) | function mt(n){return dt(n)+""}
  function yt (line 1) | function yt(n,t,e){return new xt(n,t,e)}
  function xt (line 1) | function xt(n,t,e){this.r=n,this.g=t,this.b=e}
  function Mt (line 1) | function Mt(n){return 16>n?"0"+Math.max(0,n).toString(16):Math.min(255,n...
  function _t (line 1) | function _t(n,t,e){var r,u,i,o=0,a=0,c=0;if(r=/([a-z]+)\((.*)\)/i.exec(n...
  function bt (line 1) | function bt(n,t,e){var r,u,i=Math.min(n/=255,t/=255,e/=255),o=Math.max(n...
  function wt (line 1) | function wt(n,t,e){n=St(n),t=St(t),e=St(e);var r=pt((.4124564*n+.3575761...
  function St (line 1) | function St(n){return(n/=255)<=.04045?n/12.92:Math.pow((n+.055)/1.055,2.4)}
  function kt (line 1) | function kt(n){var t=parseFloat(n);return"%"===n.charAt(n.length-1)?Math...
  function Et (line 1) | function Et(n){return"function"==typeof n?n:function(){return n}}
  function At (line 1) | function At(n){return n}
  function Ct (line 1) | function Ct(n){return function(t,e,r){return 2===arguments.length&&"func...
  function Nt (line 1) | function Nt(n,t,e,r){function u(){var n,t=c.status;if(!t&&c.responseText...
  function Lt (line 1) | function Lt(n){return 1===n.length?function(t,e){n(null==t?e:null)}:n}
  function Tt (line 1) | function Tt(){var n=qt(),t=zt()-n;t>24?(isFinite(t)&&(clearTimeout(Qa),Q...
  function qt (line 1) | function qt(){var n=Date.now();for(nc=Wa;nc;)n>=nc.t&&(nc.f=nc.c(n-nc.t)...
  function zt (line 1) | function zt(){for(var n,t=Wa,e=1/0;t;)t.f?t=n?n.n=t.n:Wa=t.n:(t.t<e&&(e=...
  function Rt (line 1) | function Rt(n,t){return t-(n?Math.ceil(Math.log(n)/Math.LN10):1)}
  function Dt (line 1) | function Dt(n,t){var e=Math.pow(10,3*fa(8-t));return{scale:t>8?function(...
  function Pt (line 1) | function Pt(n){var t=n.decimal,e=n.thousands,r=n.grouping,u=n.currency,i...
  function Ut (line 1) | function Ut(n){return n+""}
  function jt (line 1) | function jt(){this._=new Date(arguments.length>1?Date.UTC.apply(this,arg...
  function Ht (line 1) | function Ht(n,t,e){function r(t){var e=n(t),r=i(e,1);return r-t>t-e?e:r}...
  function Ft (line 1) | function Ft(n){return function(t,e){try{oc=jt;var r=new jt;return r._=t,...
  function Ot (line 1) | function Ot(n){function t(n){function t(t){for(var e,u,i,o=[],a=-1,c=0;+...
  function It (line 1) | function It(n,t,e){var r=0>n?"-":"",u=(r?-n:n)+"",i=u.length;return r+(e...
  function Yt (line 1) | function Yt(n){return new RegExp("^(?:"+n.map(Go.requote).join("|")+")",...
  function Zt (line 1) | function Zt(n){for(var t=new o,e=-1,r=n.length;++e<r;)t.set(n[e].toLower...
  function Vt (line 1) | function Vt(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+1));retu...
  function $t (line 1) | function $t(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e));return r...
  function Xt (line 1) | function Xt(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e));return r...
  function Bt (line 1) | function Bt(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+4));retu...
  function Jt (line 1) | function Jt(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+2));retu...
  function Wt (line 1) | function Wt(n,t,e){return/^[+-]\d{4}$/.test(t=t.substring(e,e+5))?(n.Z=-...
  function Gt (line 1) | function Gt(n){return n+(n>68?1900:2e3)}
  function Kt (line 1) | function Kt(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+2));retu...
  function Qt (line 1) | function Qt(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+2));retu...
  function ne (line 1) | function ne(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+3));retu...
  function te (line 1) | function te(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+2));retu...
  function ee (line 1) | function ee(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+2));retu...
  function re (line 1) | function re(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+2));retu...
  function ue (line 1) | function ue(n,t,e){sc.lastIndex=0;var r=sc.exec(t.substring(e,e+3));retu...
  function ie (line 1) | function ie(n){var t=n.getTimezoneOffset(),e=t>0?"-":"+",r=~~(fa(t)/60),...
  function oe (line 1) | function oe(n,t,e){lc.lastIndex=0;var r=lc.exec(t.substring(e,e+1));retu...
  function ae (line 1) | function ae(n){for(var t=n.length,e=-1;++e<t;)n[e][0]=this(n[e][0]);retu...
  function ce (line 1) | function ce(){}
  function se (line 1) | function se(n,t,e){var r=e.s=n+t,u=r-n,i=r-u;e.t=n-i+(t-u)}
  function le (line 1) | function le(n,t){n&&pc.hasOwnProperty(n.type)&&pc[n.type](n,t)}
  function fe (line 1) | function fe(n,t,e){var r,u=-1,i=n.length-e;for(t.lineStart();++u<i;)r=n[...
  function he (line 1) | function he(n,t){var e=-1,r=n.length;for(t.polygonStart();++e<r;)fe(n[e]...
  function ge (line 1) | function ge(){function n(n,t){n*=za,t=t*za/2+Ca/4;var e=n-r,o=e>=0?1:-1,...
  function pe (line 1) | function pe(n){var t=n[0],e=n[1],r=Math.cos(e);return[r*Math.cos(t),r*Ma...
  function ve (line 1) | function ve(n,t){return n[0]*t[0]+n[1]*t[1]+n[2]*t[2]}
  function de (line 1) | function de(n,t){return[n[1]*t[2]-n[2]*t[1],n[2]*t[0]-n[0]*t[2],n[0]*t[1...
  function me (line 1) | function me(n,t){n[0]+=t[0],n[1]+=t[1],n[2]+=t[2]}
  function ye (line 1) | function ye(n,t){return[n[0]*t,n[1]*t,n[2]*t]}
  function xe (line 1) | function xe(n){var t=Math.sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);n[0]/=t,n[...
  function Me (line 1) | function Me(n){return[Math.atan2(n[1],n[0]),G(n[2])]}
  function _e (line 1) | function _e(n,t){return fa(n[0]-t[0])<Ta&&fa(n[1]-t[1])<Ta}
  function be (line 1) | function be(n,t){n*=za;var e=Math.cos(t*=za);we(e*Math.cos(n),e*Math.sin...
  function we (line 1) | function we(n,t,e){++yc,Mc+=(n-Mc)/yc,_c+=(t-_c)/yc,bc+=(e-bc)/yc}
  function Se (line 1) | function Se(){function n(n,u){n*=za;var i=Math.cos(u*=za),o=i*Math.cos(n...
  function ke (line 1) | function ke(){Nc.point=be}
  function Ee (line 1) | function Ee(){function n(n,t){n*=za;var e=Math.cos(t*=za),o=e*Math.cos(n...
  function Ae (line 1) | function Ae(){return!0}
  function Ce (line 1) | function Ce(n,t,e,r,u){var i=[],o=[];if(n.forEach(function(n){if(!((t=n....
  function Ne (line 1) | function Ne(n){if(t=n.length){for(var t,e,r=0,u=n[0];++r<t;)u.n=e=n[r],e...
  function Le (line 1) | function Le(n,t,e,r){this.x=n,this.z=t,this.o=e,this.e=r,this.v=!1,this....
  function Te (line 1) | function Te(n,t,e,r){return function(u,i){function o(t,e){var r=u(t,e);n...
  function qe (line 1) | function qe(n){return n.length>1}
  function ze (line 1) | function ze(){var n,t=[];return{lineStart:function(){t.push(n=[])},point...
  function Re (line 1) | function Re(n,t){return((n=n.x)[0]<0?n[1]-La-Ta:La-n[1])-((t=t.x)[0]<0?t...
  function De (line 1) | function De(n,t){var e=n[0],r=n[1],u=[Math.sin(e),-Math.cos(e),0],i=0,o=...
  function Pe (line 1) | function Pe(n){var t,e=0/0,r=0/0,u=0/0;return{lineStart:function(){n.lin...
  function Ue (line 1) | function Ue(n,t,e,r){var u,i,o=Math.sin(n-e);return fa(o)>Ta?Math.atan((...
  function je (line 1) | function je(n,t,e,r){var u;if(null==n)u=e*La,r.point(-Ca,u),r.point(0,u)...
  function He (line 1) | function He(n){function t(n,t){return Math.cos(n)*Math.cos(t)>i}function...
  function Fe (line 1) | function Fe(n,t,e,r){return function(u){var i,o=u.a,a=u.b,c=o.x,s=o.y,l=...
  function Oe (line 1) | function Oe(n,t,e,r){function u(r,u){return fa(r[0]-n)<Ta?u>0?0:3:fa(r[0...
  function Ie (line 1) | function Ie(n,t){function e(e,r){return e=n(e,r),t(e[0],e[1])}return n.i...
  function Ye (line 1) | function Ye(n){var t=0,e=Ca/3,r=ir(n),u=r(t,e);return u.parallels=functi...
  function Ze (line 1) | function Ze(n,t){function e(n,t){var e=Math.sqrt(i-2*u*Math.sin(t))/u;re...
  function Ve (line 1) | function Ve(){function n(n,t){zc+=u*n-r*t,r=n,u=t}var t,e,r,u;jc.point=f...
  function $e (line 1) | function $e(n,t){Rc>n&&(Rc=n),n>Pc&&(Pc=n),Dc>t&&(Dc=t),t>Uc&&(Uc=t)}
  function Xe (line 1) | function Xe(){function n(n,t){o.push("M",n,",",t,i)}function t(n,t){o.pu...
  function Be (line 1) | function Be(n){return"m0,"+n+"a"+n+","+n+" 0 1,1 0,"+-2*n+"a"+n+","+n+" ...
  function Je (line 1) | function Je(n,t){Mc+=n,_c+=t,++bc}
  function We (line 1) | function We(){function n(n,r){var u=n-t,i=r-e,o=Math.sqrt(u*u+i*i);wc+=o...
  function Ge (line 1) | function Ge(){Fc.point=Je}
  function Ke (line 1) | function Ke(){function n(n,t){var e=n-r,i=t-u,o=Math.sqrt(e*e+i*i);wc+=o...
  function Qe (line 1) | function Qe(n){function t(t,e){n.moveTo(t,e),n.arc(t,e,o,0,Na)}function ...
  function nr (line 1) | function nr(n){function t(n){return(a?r:e)(n)}function e(t){return rr(t,...
  function tr (line 1) | function tr(n){var t=nr(function(t,e){return n([t*Ra,e*Ra])});return fun...
  function er (line 1) | function er(n){this.stream=n}
  function rr (line 1) | function rr(n,t){return{point:t,sphere:function(){n.sphere()},lineStart:...
  function ur (line 1) | function ur(n){return ir(function(){return n})()}
  function ir (line 1) | function ir(n){function t(n){return n=a(n[0]*za,n[1]*za),[n[0]*h+c,s-n[1...
  function or (line 2) | function or(n){return rr(n,function(t,e){n.point(t*za,e*za)})}
  function ar (line 2) | function ar(n,t){return[n,t]}
  function cr (line 2) | function cr(n,t){return[n>Ca?n-Na:-Ca>n?n+Na:n,t]}
  function sr (line 2) | function sr(n,t,e){return n?t||e?Ie(fr(n),hr(t,e)):fr(n):t||e?hr(t,e):cr}
  function lr (line 2) | function lr(n){return function(t,e){return t+=n,[t>Ca?t-Na:-Ca>t?t+Na:t,...
  function fr (line 2) | function fr(n){var t=lr(n);return t.invert=lr(-n),t}
  function hr (line 2) | function hr(n,t){function e(n,t){var e=Math.cos(t),a=Math.cos(n)*e,c=Mat...
  function gr (line 2) | function gr(n,t){var e=Math.cos(n),r=Math.sin(n);return function(u,i,o,a...
  function pr (line 2) | function pr(n,t){var e=pe(t);e[0]-=n,xe(e);var r=W(-e[1]);return((-e[2]<...
  function vr (line 2) | function vr(n,t,e){var r=Go.range(n,t-Ta,e).concat(t);return function(n)...
  function dr (line 2) | function dr(n,t,e){var r=Go.range(n,t-Ta,e).concat(t);return function(n)...
  function mr (line 2) | function mr(n){return n.source}
  function yr (line 2) | function yr(n){return n.target}
  function xr (line 2) | function xr(n,t,e,r){var u=Math.cos(t),i=Math.sin(t),o=Math.cos(r),a=Mat...
  function Mr (line 2) | function Mr(){function n(n,u){var i=Math.sin(u*=za),o=Math.cos(u),a=fa((...
  function _r (line 2) | function _r(n,t){function e(t,e){var r=Math.cos(t),u=Math.cos(e),i=n(r*u...
  function br (line 2) | function br(n,t){function e(n,t){o>0?-La+Ta>t&&(t=-La+Ta):t>La-Ta&&(t=La...
  function wr (line 2) | function wr(n,t){function e(n,t){var e=i-t;return[e*Math.sin(u*n),i-e*Ma...
  function Sr (line 2) | function Sr(n,t){return[n,Math.log(Math.tan(Ca/4+t/2))]}
  function kr (line 2) | function kr(n){var t,e=ur(n),r=e.scale,u=e.translate,i=e.clipExtent;retu...
  function Er (line 2) | function Er(n,t){return[Math.log(Math.tan(Ca/4+t/2)),-n]}
  function Ar (line 2) | function Ar(n){return n[0]}
  function Cr (line 2) | function Cr(n){return n[1]}
  function Nr (line 2) | function Nr(n){for(var t=n.length,e=[0,1],r=2,u=2;t>u;u++){for(;r>1&&J(n...
  function Lr (line 2) | function Lr(n,t){return n[0]-t[0]||n[1]-t[1]}
  function Tr (line 2) | function Tr(n,t,e){return(e[0]-t[0])*(n[1]-t[1])<(e[1]-t[1])*(n[0]-t[0])}
  function qr (line 2) | function qr(n,t,e,r){var u=n[0],i=e[0],o=t[0]-u,a=r[0]-i,c=n[1],s=e[1],l...
  function zr (line 2) | function zr(n){var t=n[0],e=n[n.length-1];return!(t[0]-e[0]||t[1]-e[1])}
  function Rr (line 2) | function Rr(){tu(this),this.edge=this.site=this.circle=null}
  function Dr (line 2) | function Dr(n){var t=ns.pop()||new Rr;return t.site=n,t}
  function Pr (line 2) | function Pr(n){$r(n),Gc.remove(n),ns.push(n),tu(n)}
  function Ur (line 2) | function Ur(n){var t=n.circle,e=t.x,r=t.cy,u={x:e,y:r},i=n.P,o=n.N,a=[n]...
  function jr (line 2) | function jr(n){for(var t,e,r,u,i=n.x,o=n.y,a=Gc._;a;)if(r=Hr(a,o)-i,r>Ta...
  function Hr (line 2) | function Hr(n,t){var e=n.site,r=e.x,u=e.y,i=u-t;if(!i)return r;var o=n.P...
  function Fr (line 2) | function Fr(n,t){var e=n.N;if(e)return Hr(e,t);var r=n.site;return r.y==...
  function Or (line 2) | function Or(n){this.site=n,this.edges=[]}
  function Ir (line 2) | function Ir(n){for(var t,e,r,u,i,o,a,c,s,l,f=n[0][0],h=n[1][0],g=n[0][1]...
  function Yr (line 2) | function Yr(n,t){return t.angle-n.angle}
  function Zr (line 2) | function Zr(){tu(this),this.x=this.y=this.arc=this.site=this.cy=null}
  function Vr (line 2) | function Vr(n){var t=n.P,e=n.N;if(t&&e){var r=t.site,u=n.site,i=e.site;i...
  function $r (line 2) | function $r(n){var t=n.circle;t&&(t.P||(Kc=t.N),Qc.remove(t),ts.push(t),...
  function Xr (line 2) | function Xr(n){for(var t,e=Jc,r=Fe(n[0][0],n[0][1],n[1][0],n[1][1]),u=e....
  function Br (line 2) | function Br(n,t){var e=n.b;if(e)return!0;var r,u,i=n.a,o=t[0][0],a=t[1][...
  function Jr (line 2) | function Jr(n,t){this.l=n,this.r=t,this.a=this.b=null}
  function Wr (line 2) | function Wr(n,t,e,r){var u=new Jr(n,t);return Jc.push(u),e&&Kr(u,n,t,e),...
  function Gr (line 2) | function Gr(n,t,e){var r=new Jr(n,null);return r.a=t,r.b=e,Jc.push(r),r}
  function Kr (line 2) | function Kr(n,t,e,r){n.a||n.b?n.l===e?n.b=r:n.a=r:(n.a=r,n.l=t,n.r=e)}
  function Qr (line 2) | function Qr(n,t,e){var r=n.a,u=n.b;this.edge=n,this.site=t,this.angle=e?...
  function nu (line 2) | function nu(){this._=null}
  function tu (line 2) | function tu(n){n.U=n.C=n.L=n.R=n.P=n.N=null}
  function eu (line 2) | function eu(n,t){var e=t,r=t.R,u=e.U;u?u.L===e?u.L=r:u.R=r:n._=r,r.U=u,e...
  function ru (line 2) | function ru(n,t){var e=t,r=t.L,u=e.U;u?u.L===e?u.L=r:u.R=r:n._=r,r.U=u,e...
  function uu (line 2) | function uu(n){for(;n.L;)n=n.L;return n}
  function iu (line 2) | function iu(n,t){var e,r,u,i=n.sort(ou).pop();for(Jc=[],Wc=new Array(n.l...
  function ou (line 2) | function ou(n,t){return t.y-n.y||t.x-n.x}
  function au (line 2) | function au(n,t,e){return(n.x-e.x)*(t.y-n.y)-(n.x-t.x)*(e.y-n.y)}
  function cu (line 2) | function cu(n){return n.x}
  function su (line 2) | function su(n){return n.y}
  function lu (line 2) | function lu(){return{leaf:!0,nodes:[],point:null,x:null,y:null}}
  function fu (line 2) | function fu(n,t,e,r,u,i){if(!n(t,e,r,u,i)){var o=.5*(e+u),a=.5*(r+i),c=t...
  function hu (line 2) | function hu(n,t){n=Go.rgb(n),t=Go.rgb(t);var e=n.r,r=n.g,u=n.b,i=t.r-e,o...
  function gu (line 2) | function gu(n,t){var e,r={},u={};for(e in n)e in t?r[e]=du(n[e],t[e]):u[...
  function pu (line 2) | function pu(n,t){return t-=n=+n,function(e){return n+t*e}}
  function vu (line 2) | function vu(n,t){var e,r,u,i=rs.lastIndex=us.lastIndex=0,o=-1,a=[],c=[];...
  function du (line 2) | function du(n,t){for(var e,r=Go.interpolators.length;--r>=0&&!(e=Go.inte...
  function mu (line 2) | function mu(n,t){var e,r=[],u=[],i=n.length,o=t.length,a=Math.min(n.leng...
  function yu (line 2) | function yu(n){return function(t){return 0>=t?0:t>=1?1:n(t)}}
  function xu (line 2) | function xu(n){return function(t){return 1-n(1-t)}}
  function Mu (line 2) | function Mu(n){return function(t){return.5*(.5>t?n(2*t):2-n(2-2*t))}}
  function _u (line 2) | function _u(n){return n*n}
  function bu (line 2) | function bu(n){return n*n*n}
  function wu (line 2) | function wu(n){if(0>=n)return 0;if(n>=1)return 1;var t=n*n,e=t*n;return ...
  function Su (line 2) | function Su(n){return function(t){return Math.pow(t,n)}}
  function ku (line 2) | function ku(n){return 1-Math.cos(n*La)}
  function Eu (line 2) | function Eu(n){return Math.pow(2,10*(n-1))}
  function Au (line 2) | function Au(n){return 1-Math.sqrt(1-n*n)}
  function Cu (line 2) | function Cu(n,t){var e;return arguments.length<2&&(t=.45),arguments.leng...
  function Nu (line 2) | function Nu(n){return n||(n=1.70158),function(t){return t*t*((n+1)*t-n)}}
  function Lu (line 2) | function Lu(n){return 1/2.75>n?7.5625*n*n:2/2.75>n?7.5625*(n-=1.5/2.75)*...
  function Tu (line 2) | function Tu(n,t){n=Go.hcl(n),t=Go.hcl(t);var e=n.h,r=n.c,u=n.l,i=t.h-e,o...
  function qu (line 2) | function qu(n,t){n=Go.hsl(n),t=Go.hsl(t);var e=n.h,r=n.s,u=n.l,i=t.h-e,o...
  function zu (line 2) | function zu(n,t){n=Go.lab(n),t=Go.lab(t);var e=n.l,r=n.a,u=n.b,i=t.l-e,o...
  function Ru (line 2) | function Ru(n,t){return t-=n,function(e){return Math.round(n+t*e)}}
  function Du (line 2) | function Du(n){var t=[n.a,n.b],e=[n.c,n.d],r=Uu(t),u=Pu(t,e),i=Uu(ju(e,t...
  function Pu (line 2) | function Pu(n,t){return n[0]*t[0]+n[1]*t[1]}
  function Uu (line 2) | function Uu(n){var t=Math.sqrt(Pu(n,n));return t&&(n[0]/=t,n[1]/=t),t}
  function ju (line 2) | function ju(n,t,e){return n[0]+=e*t[0],n[1]+=e*t[1],n}
  function Hu (line 2) | function Hu(n,t){var e,r=[],u=[],i=Go.transform(n),o=Go.transform(t),a=i...
  function Fu (line 2) | function Fu(n,t){return t=t-(n=+n)?1/(t-n):0,function(e){return(e-n)*t}}
  function Ou (line 2) | function Ou(n,t){return t=t-(n=+n)?1/(t-n):0,function(e){return Math.max...
  function Iu (line 2) | function Iu(n){for(var t=n.source,e=n.target,r=Zu(t,e),u=[t];t!==r;)t=t....
  function Yu (line 2) | function Yu(n){for(var t=[],e=n.parent;null!=e;)t.push(n),n=e,e=e.parent...
  function Zu (line 2) | function Zu(n,t){if(n===t)return n;for(var e=Yu(n),r=Yu(t),u=e.pop(),i=r...
  function Vu (line 2) | function Vu(n){n.fixed|=2}
  function $u (line 2) | function $u(n){n.fixed&=-7}
  function Xu (line 2) | function Xu(n){n.fixed|=4,n.px=n.x,n.py=n.y}
  function Bu (line 2) | function Bu(n){n.fixed&=-5}
  function Ju (line 2) | function Ju(n,t,e){var r=0,u=0;if(n.charge=0,!n.leaf)for(var i,o=n.nodes...
  function Wu (line 2) | function Wu(n,t){return Go.rebind(n,t,"sort","children","value"),n.nodes...
  function Gu (line 2) | function Gu(n){return n.children}
  function Ku (line 2) | function Ku(n){return n.value}
  function Qu (line 2) | function Qu(n,t){return t.value-n.value}
  function ni (line 2) | function ni(n){return Go.merge(n.map(function(n){return(n.children||[])....
  function ti (line 2) | function ti(n){return n.x}
  function ei (line 2) | function ei(n){return n.y}
  function ri (line 2) | function ri(n,t,e){n.y0=t,n.y=e}
  function ui (line 2) | function ui(n){return Go.range(n.length)}
  function ii (line 2) | function ii(n){for(var t=-1,e=n[0].length,r=[];++t<e;)r[t]=0;return r}
  function oi (line 2) | function oi(n){for(var t,e=1,r=0,u=n[0][1],i=n.length;i>e;++e)(t=n[e][1]...
  function ai (line 2) | function ai(n){return n.reduce(ci,0)}
  function ci (line 2) | function ci(n,t){return n+t[1]}
  function si (line 2) | function si(n,t){return li(n,Math.ceil(Math.log(t.length)/Math.LN2+1))}
  function li (line 2) | function li(n,t){for(var e=-1,r=+n[0],u=(n[1]-r)/t,i=[];++e<=t;)i[e]=u*e...
  function fi (line 2) | function fi(n){return[Go.min(n),Go.max(n)]}
  function hi (line 2) | function hi(n,t){return n.parent==t.parent?1:2}
  function gi (line 2) | function gi(n){var t=n.children;return t&&t.length?t[0]:n._tree.thread}
  function pi (line 2) | function pi(n){var t,e=n.children;return e&&(t=e.length)?e[t-1]:n._tree....
  function vi (line 2) | function vi(n,t){var e=n.children;if(e&&(u=e.length))for(var r,u,i=-1;++...
  function di (line 2) | function di(n,t){return n.x-t.x}
  function mi (line 2) | function mi(n,t){return t.x-n.x}
  function yi (line 2) | function yi(n,t){return n.depth-t.depth}
  function xi (line 2) | function xi(n,t){function e(n,r){var u=n.children;if(u&&(o=u.length))for...
  function Mi (line 2) | function Mi(n){for(var t,e=0,r=0,u=n.children,i=u.length;--i>=0;)t=u[i]....
  function _i (line 2) | function _i(n,t,e){n=n._tree,t=t._tree;var r=e/(t.number-n.number);n.cha...
  function bi (line 2) | function bi(n,t,e){return n._tree.ancestor.parent==t.parent?n._tree.ance...
  function wi (line 2) | function wi(n,t){return n.value-t.value}
  function Si (line 2) | function Si(n,t){var e=n._pack_next;n._pack_next=t,t._pack_prev=n,t._pac...
  function ki (line 2) | function ki(n,t){n._pack_next=t,t._pack_prev=n}
  function Ei (line 2) | function Ei(n,t){var e=t.x-n.x,r=t.y-n.y,u=n.r+t.r;return.999*u*u>e*e+r*r}
  function Ai (line 2) | function Ai(n){function t(n){l=Math.min(n.x-n.r,l),f=Math.max(n.x+n.r,f)...
  function Ci (line 2) | function Ci(n){n._pack_next=n._pack_prev=n}
  function Ni (line 2) | function Ni(n){delete n._pack_next,delete n._pack_prev}
  function Li (line 2) | function Li(n,t,e,r){var u=n.children;if(n.x=t+=r*n.x,n.y=e+=r*n.y,n.r*=...
  function Ti (line 2) | function Ti(n,t,e){var r=n.r+e.r,u=t.x-n.x,i=t.y-n.y;if(r&&(u||i)){var o...
  function qi (line 2) | function qi(n){return 1+Go.max(n,function(n){return n.y})}
  function zi (line 2) | function zi(n){return n.reduce(function(n,t){return n+t.x},0)/n.length}
  function Ri (line 2) | function Ri(n){var t=n.children;return t&&t.length?Ri(t[0]):n}
  function Di (line 2) | function Di(n){var t,e=n.children;return e&&(t=e.length)?Di(e[t-1]):n}
  function Pi (line 2) | function Pi(n){return{x:n.x,y:n.y,dx:n.dx,dy:n.dy}}
  function Ui (line 2) | function Ui(n,t){var e=n.x+t[3],r=n.y+t[0],u=n.dx-t[1]-t[3],i=n.dy-t[0]-...
  function ji (line 2) | function ji(n){var t=n[0],e=n[n.length-1];return e>t?[t,e]:[e,t]}
  function Hi (line 2) | function Hi(n){return n.rangeExtent?n.rangeExtent():ji(n.range())}
  function Fi (line 2) | function Fi(n,t,e,r){var u=e(n[0],n[1]),i=r(t[0],t[1]);return function(n...
  function Oi (line 2) | function Oi(n,t){var e,r=0,u=n.length-1,i=n[r],o=n[u];return i>o&&(e=r,r...
  function Ii (line 2) | function Ii(n){return n?{floor:function(t){return Math.floor(t/n)*n},cei...
  function Yi (line 2) | function Yi(n,t,e,r){var u=[],i=[],o=0,a=Math.min(n.length,t.length)-1;f...
  function Zi (line 2) | function Zi(n,t,e,r){function u(){var u=Math.min(n.length,t.length)>2?Yi...
  function Vi (line 2) | function Vi(n,t){return Go.rebind(n,t,"range","rangeRound","interpolate"...
  function $i (line 2) | function $i(n,t){return Oi(n,Ii(Xi(n,t)[2]))}
  function Xi (line 2) | function Xi(n,t){null==t&&(t=10);var e=ji(n),r=e[1]-e[0],u=Math.pow(10,M...
  function Bi (line 2) | function Bi(n,t){return Go.range.apply(Go,Xi(n,t))}
  function Ji (line 2) | function Ji(n,t,e){var r=Xi(n,t);if(e){var u=rc.exec(e);if(u.shift(),"s"...
  function Wi (line 2) | function Wi(n){return-Math.floor(Math.log(n)/Math.LN10+.01)}
  function Gi (line 2) | function Gi(n,t){var e=Wi(t[2]);return n in ds?Math.abs(e-Wi(Math.max(fa...
  function Ki (line 2) | function Ki(n,t,e,r){function u(n){return(e?Math.log(0>n?0:n):-Math.log(...
  function Qi (line 2) | function Qi(n,t,e){function r(t){return n(u(t))}var u=no(t),i=no(1/t);re...
  function no (line 2) | function no(n){return function(t){return 0>t?-Math.pow(-t,n):Math.pow(t,...
  function to (line 2) | function to(n,t){function e(e){return i[((u.get(e)||("range"===t.t?u.set...
  function eo (line 2) | function eo(e,r){function u(){var n=0,t=r.length;for(o=[];++n<t;)o[n-1]=...
  function ro (line 2) | function ro(n,t,e){function r(t){return e[Math.max(0,Math.min(o,Math.flo...
  function uo (line 2) | function uo(n,t){function e(e){return e>=e?t[Go.bisect(n,e)]:void 0}retu...
  function io (line 2) | function io(n){function t(n){return+n}return t.invert=t,t.domain=t.range...
  function oo (line 2) | function oo(n){return n.innerRadius}
  function ao (line 2) | function ao(n){return n.outerRadius}
  function co (line 2) | function co(n){return n.startAngle}
  function so (line 2) | function so(n){return n.endAngle}
  function lo (line 2) | function lo(n){function t(t){function o(){s.push("M",i(n(l),a))}for(var ...
  function fo (line 2) | function fo(n){return n.join("L")}
  function ho (line 2) | function ho(n){return fo(n)+"Z"}
  function go (line 2) | function go(n){for(var t=0,e=n.length,r=n[0],u=[r[0],",",r[1]];++t<e;)u....
  function po (line 2) | function po(n){for(var t=0,e=n.length,r=n[0],u=[r[0],",",r[1]];++t<e;)u....
  function vo (line 2) | function vo(n){for(var t=0,e=n.length,r=n[0],u=[r[0],",",r[1]];++t<e;)u....
  function mo (line 2) | function mo(n,t){return n.length<4?fo(n):n[1]+Mo(n.slice(1,n.length-1),_...
  function yo (line 2) | function yo(n,t){return n.length<3?fo(n):n[0]+Mo((n.push(n[0]),n),_o([n[...
  function xo (line 2) | function xo(n,t){return n.length<3?fo(n):n[0]+Mo(n,_o(n,t))}
  function Mo (line 2) | function Mo(n,t){if(t.length<1||n.length!=t.length&&n.length!=t.length+2...
  function _o (line 2) | function _o(n,t){for(var e,r=[],u=(1-t)/2,i=n[0],o=n[1],a=1,c=n.length;+...
  function bo (line 2) | function bo(n){if(n.length<3)return fo(n);var t=1,e=n.length,r=n[0],u=r[...
  function wo (line 2) | function wo(n){if(n.length<4)return fo(n);for(var t,e=[],r=-1,u=n.length...
  function So (line 2) | function So(n){for(var t,e,r=-1,u=n.length,i=u+4,o=[],a=[];++r<4;)e=n[r%...
  function ko (line 2) | function ko(n,t){var e=n.length-1;if(e)for(var r,u,i=n[0][0],o=n[0][1],a...
  function Eo (line 2) | function Eo(n,t){return n[0]*t[0]+n[1]*t[1]+n[2]*t[2]+n[3]*t[3]}
  function Ao (line 2) | function Ao(n,t,e){n.push("C",Eo(Es,t),",",Eo(Es,e),",",Eo(As,t),",",Eo(...
  function Co (line 2) | function Co(n,t){return(t[1]-n[1])/(t[0]-n[0])}
  function No (line 2) | function No(n){for(var t=0,e=n.length-1,r=[],u=n[0],i=n[1],o=r[0]=Co(u,i...
  function Lo (line 2) | function Lo(n){for(var t,e,r,u,i=[],o=No(n),a=-1,c=n.length-1;++a<c;)t=C...
  function To (line 2) | function To(n){return n.length<3?fo(n):n[0]+Mo(n,Lo(n))}
  function qo (line 2) | function qo(n){for(var t,e,r,u=-1,i=n.length;++u<i;)t=n[u],e=t[0],r=t[1]...
  function zo (line 2) | function zo(n){function t(t){function c(){v.push("M",a(n(m),f),l,s(n(d.r...
  function Ro (line 2) | function Ro(n){return n.radius}
  function Do (line 2) | function Do(n){return[n.x,n.y]}
  function Po (line 2) | function Po(n){return function(){var t=n.apply(this,arguments),e=t[0],r=...
  function Uo (line 2) | function Uo(){return 64}
  function jo (line 2) | function jo(){return"circle"}
  function Ho (line 2) | function Ho(n){var t=Math.sqrt(n/Ca);return"M0,"+t+"A"+t+","+t+" 0 1,1 0...
  function Fo (line 2) | function Fo(n,t){return da(n,Rs),n.id=t,n}
  function Oo (line 2) | function Oo(n,t,e,r){var u=n.id;return P(n,"function"==typeof e?function...
  function Io (line 2) | function Io(n){return null==n&&(n=""),function(){this.textContent=n}}
  function Yo (line 2) | function Yo(n,t,e,r){var u=n.__transition__||(n.__transition__={active:0...
  function Zo (line 2) | function Zo(n,t){n.attr("transform",function(n){return"translate("+t(n)+...
  function Vo (line 2) | function Vo(n,t){n.attr("transform",function(n){return"translate(0,"+t(n...
  function $o (line 2) | function $o(n){return n.toISOString()}
  function Xo (line 2) | function Xo(n,t,e){function r(t){return n(t)
  function Bo (line 3) | function Bo(n){return new Date(n)}
  function Jo (line 3) | function Jo(n){return JSON.parse(n.responseText)}
  function Wo (line 3) | function Wo(n){var t=na.createRange();return t.selectNode(na.body),t.cre...
  function n (line 3) | function n(t,a,c){if(c>=i.length)return r?r.call(u,a):e?a.sort(e):a;for(...
  function t (line 3) | function t(n,e){if(e>=i.length)return n;var r=[],u=a[e++];return n.forEa...
  function e (line 3) | function e(n,e){var r,u,i,a=n.length,f=e.length,h=Math.min(a,f),g=new Ar...
  function n (line 3) | function n(){this.on("mousedown.drag",u).on("touchstart.drag",i)}
  function t (line 3) | function t(n,t,u,i,o){return function(){function a(){var n,e,r=t(h,v);r&...
  function e (line 3) | function e(n){var t=n*y;if(m){var e=Q(v),o=i/(Pa*h)*(e*nt(Da*t+v)-K(v));...
  function n (line 3) | function n(n){n.on(A,s).on(Fa+".zoom",f).on(C,h).on("dblclick.zoom",g).o...
  function t (line 3) | function t(n){return[(n[0]-S.x)/S.k,(n[1]-S.y)/S.k]}
  function e (line 3) | function e(n){return[n[0]*S.k+S.x,n[1]*S.k+S.y]}
  function r (line 3) | function r(n){S.k=Math.max(E[0],Math.min(E[1],n))}
  function u (line 3) | function u(n,t){t=e(t),S.x+=n[0]-t[0],S.y+=n[1]-t[1]}
  function i (line 3) | function i(){_&&_.domain(x.range().map(function(n){return(n-S.x)/S.k}).m...
  function o (line 3) | function o(n){n({type:"zoomstart"})}
  function a (line 3) | function a(n){i(),n({type:"zoom",scale:S.k,translate:[S.x,S.y]})}
  function c (line 3) | function c(n){n({type:"zoomend"})}
  function s (line 3) | function s(){function n(){l=1,u(Go.mouse(r),g),a(s)}function e(){f.on(C,...
  function l (line 3) | function l(){function n(){var n=Go.touches(g);return h=S.k,n.forEach(fun...
  function f (line 3) | function f(){var n=T.of(this,arguments);d?clearTimeout(d):(H.call(this),...
  function h (line 3) | function h(){p=null}
  function g (line 3) | function g(){var n=T.of(this,arguments),e=Go.mouse(this),i=t(e),s=Math.l...
  function e (line 3) | function e(n,e,i){arguments.length<3&&(i=e,e=null);var o=Nt(n,t,null==e?...
  function r (line 3) | function r(n){return e.parse(n.responseText)}
  function u (line 3) | function u(n){return function(t){return e.parse(t.responseText,n)}}
  function i (line 3) | function i(t){return t.map(o).join(n)}
  function o (line 3) | function o(n){return a.test(n)?'"'+n.replace(/\"/g,'""')+'"':n}
  function e (line 3) | function e(){if(l>=s)return o;if(u)return u=!1,i;var t=l;if(34===n.charC...
  function n (line 3) | function n(n,t){x.push(M=[l=n,h=n]),f>t&&(f=t),t>g&&(g=t)}
  function t (line 3) | function t(t,e){var r=pe([t*za,e*za]);if(m){var u=de(m,r),i=[u[1],-u[0],...
  function e (line 3) | function e(){_.point=t}
  function r (line 3) | function r(){M[0]=l,M[1]=h,_.point=n,m=null}
  function u (line 3) | function u(n,e){if(m){var r=n-p;y+=fa(r)>180?r+(r>0?360:-360):r}else v=n...
  function i (line 3) | function i(){mc.lineStart()}
  function o (line 3) | function o(){u(v,d),mc.lineEnd(),fa(y)>Ta&&(l=-(h=180)),M[0]=l,M[1]=h,m=...
  function a (line 3) | function a(n,t){return(t-=n)<0?t+360:t}
  function c (line 3) | function c(n,t){return n[0]-t[0]}
  function s (line 3) | function s(n,t){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:n<t[0]||t[1]<n}
  function n (line 4) | function n(n){var i=n[0],o=n[1];return t=null,e(i,o),t||(r(i,o),t)||u(i,...
  function n (line 4) | function n(n){return n&&("function"==typeof a&&i.pointRadius(+a.apply(th...
  function t (line 4) | function t(){return o=null,n}
  function t (line 4) | function t(t){return t=n(t[0]*za,t[1]*za),t[0]*=Ra,t[1]*=Ra,t}
  function n (line 4) | function n(){var n="function"==typeof r?r.apply(this,arguments):r,t=sr(-...
  function n (line 4) | function n(){return{type:"MultiLineString",coordinates:t()}}
  function t (line 4) | function t(){return Go.range(Math.ceil(i/d)*d,u,d).map(h).concat(Go.rang...
  function n (line 4) | function n(){return{type:"LineString",coordinates:[t||r.apply(this,argum...
  function t (line 4) | function t(n){if(n.length<3)return[];var t,u=Et(e),i=Et(r),o=n.length,a=...
  function t (line 4) | function t(n){var t=new Array(n.length),r=a[0][0],u=a[0][1],i=a[1][0],o=...
  function e (line 4) | function e(n){return n.map(function(n,t){return{x:Math.round(i(n,t)/Ta)*...
  function i (line 4) | function i(n){function i(n,t,e,r,u,i,o,a){if(!isNaN(e)&&!isNaN(r))if(n.l...
  function n (line 4) | function n(){var n,s,f,h,g,p={},v=[],d=Go.range(i),m=[];for(e=[],r=[],n=...
  function t (line 4) | function t(){e.sort(function(n,t){return c((n.source.value+n.target.valu...
  function n (line 4) | function n(n){return function(t,e,r,u){if(t.point!==n){var i=t.cx-n.x,o=...
  function t (line 4) | function t(n){n.px=Go.event.x,n.py=Go.event.y,a.resume()}
  function n (line 4) | function n(n,r){if(!e){for(e=new Array(c),a=0;c>a;++a)e[a]=[];for(a=0;s>...
  function n (line 4) | function n(t,o,a){var c=u.call(e,t,o);if(t.depth=o,a.push(t),c&&(s=c.len...
  function t (line 4) | function t(n,r){var u=n.children,o=0;if(u&&(a=u.length))for(var a,c=-1,s...
  function e (line 4) | function e(t){var e=[];return n(t,0,e),e}
  function n (line 4) | function n(t,e,r,u){var i=t.children;if(t.x=e,t.y=t.depth*u,t.dx=r,t.dy=...
  function t (line 4) | function t(n){var e=n.children,r=0;if(e&&(u=e.length))for(var u,i=-1;++i...
  function e (line 4) | function e(e,i){var o=r.call(this,e,i);return n(o[0],0,u[0],u[1]/t(o[0])...
  function n (line 4) | function n(i){var o=i.map(function(e,r){return+t.call(n,e,r)}),a=+("func...
  function n (line 4) | function n(a,c){var s=a.map(function(e,r){return t.call(n,e,r)}),l=s.map...
  function n (line 4) | function n(n,i){for(var o,a,c=[],s=n.map(e,this),l=r.call(this,s,i),f=u....
  function n (line 4) | function n(n,i){function o(n,t){var r=n.children,u=n._tree;if(r&&(i=r.le...
  function n (line 4) | function n(n,i){var o=e.call(this,n,i),a=o[0],c=u[0],s=u[1],l=null==t?Ma...
  function n (line 4) | function n(n,i){var o,a=t.call(this,n,i),c=a[0],s=0;xi(c,function(n){var...
  function n (line 4) | function n(n,t){for(var e,r,u=-1,i=n.length;++u<i;)r=(e=n[u]).value*(0>t...
  function t (line 4) | function t(e){var i=e.children;if(i&&i.length){var o,a,c,s=f(e),l=[],h=i...
  function e (line 4) | function e(t){var r=t.children;if(r&&r.length){var i,o=f(t),a=r.slice(),...
  function r (line 4) | function r(n,t){for(var e,r=n.area,u=0,i=1/0,o=-1,a=n.length;++o<a;)(e=n...
  function u (line 4) | function u(n,t,e,r){var u,i=-1,o=n.length,a=e.x,s=e.y,l=t?c(n.area/t):0;...
  function i (line 4) | function i(r){var u=o||a(r),i=u[0];return i.x=0,i.y=0,i.dx=s[0],i.dy=s[1...
  function t (line 4) | function t(t){var e=n.call(i,t,t.depth);return null==e?Pi(t):Ui(t,"numbe...
  function e (line 4) | function e(t){return Ui(t,n)}
  function n (line 4) | function n(){var n=t.apply(this,arguments),i=e.apply(this,arguments),o=r...
  function n (line 5) | function n(n,a){var c=t(this,i,n,a),s=t(this,o,n,a);return"M"+c.p0+r(c.r...
  function t (line 5) | function t(n,t,e,r){var u=t.call(n,e,r),i=a.call(n,u,r),o=c.call(n,u,r)+...
  function e (line 5) | function e(n,t){return n.a0==t.a0&&n.a1==t.a1}
  function r (line 5) | function r(n,t,e){return"A"+n+","+n+" 0 "+ +(e>Ca)+",1 "+t}
  function u (line 5) | function u(n,t,e,r){return"Q 0,0 "+r}
  function n (line 5) | function n(n,u){var i=t.call(this,n,u),o=e.call(this,n,u),a=(i.y+o.y)/2,...
  function n (line 5) | function n(n,r){return(Ns.get(t.call(this,n,r))||Ho)(e.call(this,n,r))}
  function e (line 5) | function e(){this.removeAttribute(a)}
  function r (line 5) | function r(){this.removeAttributeNS(a.space,a.local)}
  function u (line 5) | function u(n){return null==n?e:(n+="",function(){var t,e=this.getAttribu...
  function i (line 5) | function i(n){return null==n?r:(n+="",function(){var t,e=this.getAttribu...
  function e (line 5) | function e(n,e){var r=t.call(this,n,e,this.getAttribute(u));return r&&fu...
  function r (line 5) | function r(n,e){var r=t.call(this,n,e,this.getAttributeNS(u.space,u.loca...
  function r (line 5) | function r(){this.style.removeProperty(n)}
  function u (line 5) | function u(t){return null==t?r:(t+="",function(){var r,u=ea.getComputedS...
  function r (line 5) | function r(r,u){var i=t.call(this,r,u,ea.getComputedStyle(this,null).get...
  function n (line 5) | function n(n){n.each(function(){var n,s=Go.select(this),l=this.__chart__...
  function n (line 5) | function n(i){i.each(function(){var i=Go.select(this).style("pointer-eve...
  function t (line 5) | function t(n){n.selectAll(".resize").attr("transform",function(n){return...
  function e (line 5) | function e(n){n.select(".extent").attr("x",l[0]),n.selectAll(".extent,.n...
  function r (line 5) | function r(n){n.select(".extent").attr("y",f[0]),n.selectAll(".extent,.e...
  function u (line 5) | function u(){function u(){32==Go.event.keyCode&&(C||(x=null,L[0]-=l[1],L...

FILE: shared-data/contrib/forcegrapher/forcegrapher.py
  class Graph (line 15) | class Graph(Search):
    method command (line 21) | def command(self, search=None):

FILE: shared-data/contrib/hacks/hacks.py
  class Hacks (line 20) | class Hacks(Command):
    method command (line 26) | def command(self):
  class FixIndex (line 30) | class FixIndex(Hacks):
    method command (line 35) | def command(self):
  class PyCLI (line 67) | class PyCLI(Hacks):
    method command (line 72) | def command(self):
  class ViewMetadata (line 105) | class ViewMetadata(Hacks):
    method _explain (line 109) | def _explain(self, i):
    method command (line 155) | def command(self):
  class EditMetadata (line 160) | class EditMetadata(ViewMetadata):
    method _new_raw_data (line 165) | def _new_raw_data(self, op):
    method _edit (line 171) | def _edit(self, op, i):
    method command (line 197) | def command(self):
  class ViewKeywords (line 204) | class ViewKeywords(Hacks):
    method _explain (line 208) | def _explain(self, i):
    method command (line 218) | def command(self):
  class ViewHeaderPrint (line 223) | class ViewHeaderPrint(Hacks):
    method _explain (line 227) | def _explain(self, i):
    method command (line 240) | def command(self):
  class Http (line 247) | class Http(Hacks):
    method command (line 256) | def command(self):
  class CheckMailbox (line 319) | class CheckMailbox(Hacks):
    method command (line 325) | def command(self):
  class FakeSendingDates (line 530) | class FakeSendingDates(Hacks):
    method command (line 534) | def command(self):

FILE: shared-data/contrib/hints/hints.py
  class hintsCommand (line 22) | class hintsCommand(Command):
    method _today (line 86) | def _today(self):
    method timestamps (line 89) | def timestamps(self):
    method save_timestamps (line 99) | def save_timestamps(self):
    method _days (line 104) | def _days(self):
    method _hint_days (line 107) | def _hint_days(self, hint):
    method _postpone_hint (line 112) | def _postpone_hint(self, hint, days=None):
    method _hint_applies (line 118) | def _hint_applies(self, hint, ctx):
    method _hint_event (line 124) | def _hint_event(self, ctx, hint):
    method _choose_hint (line 147) | def _choose_hint(self, ctx):
    method command (line 162) | def command(self):

FILE: shared-data/contrib/i18nhelper/i18nhelper.py
  class I18NRecent (line 7) | class I18NRecent(Command):
    class CommandResult (line 14) | class CommandResult(Command.CommandResult):
      method as_text (line 15) | def as_text(self):
    method command (line 21) | def command(self):

FILE: shared-data/contrib/maildeck/maildeck.py
  class maildeckCommand (line 3) | class maildeckCommand(Command):

FILE: shared-data/contrib/unthread/unthread.js
  function _message_click_handler (line 3) | function _message_click_handler(e) {
  function _modal_submit_handler (line 12) | function _modal_submit_handler(e) {

FILE: shared-data/default-theme/html/jsapi/index.js
  method if (line 234) | if (command != '/0/cached/' && command != '/0/logs/events/') {
  method for (line 280) | for (var i in data._args) {
  method for (line 296) | for (var k in data) {
  function handle_event (line 422) | function handle_event(data) {

FILE: shared-data/default-theme/html/jsapi/message/html-sandbox.js
  function proxy (line 31) | function proxy() {
  function addStyles (line 62) | function addStyles(output, styles) {
  function addCSSRules (line 78) | function addCSSRules(output, cssRules) {
  function proxyAttribute (line 121) | function proxyAttribute(url) {

FILE: shared-data/default-theme/html/jsapi/search/events.js
  function show_settings (line 74) | function show_settings() {

FILE: shared-data/default-theme/html/jsapi/ui/selection.js
  function _call_callbacks (line 20) | function _call_callbacks(context, selected) {
  function context (line 25) | function context(selector) {
  function _select_all (line 28) | function _select_all(ctx) {
  function _each_checkbox (line 31) | function _each_checkbox(ctx, func) {
  function register (line 41) | function register(name, callback) {
  function unregister (line 49) | function unregister(name) {
  function select_these (line 59) | function select_these(selector, no_callbacks) {
  function select_none (line 77) | function select_none(selector, no_callbacks) {
  function select_all (line 93) | function select_all(selector, no_callbacks) {
  function select_not_all (line 107) | function select_not_all(selector, no_callbacks) {
  function selected (line 120) | function selected(selector) {
  function human_length (line 140) | function human_length(selection) {

FILE: shared-data/default-theme/html/jsapi/ui/tagging.js
  function tag_and_update_ui (line 32) | function tag_and_update_ui(options, op, callback) {

FILE: shared-data/mailpile-gui/mailpile-gui.py
  function SPLASH_SCREEN (line 51) | def SPLASH_SCREEN(state, message):
  function BASIC_GUI_CONFIGURATION (line 61) | def BASIC_GUI_CONFIGURATION(state):
  class MailpileState (line 171) | class MailpileState(object):
    method __init__ (line 172) | def __init__(self):
    method check_if_running (line 179) | def check_if_running(self):
    method _load_public_config (line 193) | def _load_public_config(self):
    method discover (line 207) | def discover(self, argv):
  function GenerateConfig (line 217) | def GenerateConfig(state):
  function LocateMailpile (line 223) | def LocateMailpile(trust_os_path=False):
  function MailpileInvocation (line 257) | def MailpileInvocation(trust_os_path=False):
  function GenerateBootstrap (line 285) | def GenerateBootstrap(state, trust_os_path=False):
  function Main (line 317) | def Main(argv):

FILE: shared-data/multipile/mailpile-admin.py
  function _escape (line 150) | def _escape(string):
  function _escaped (line 154) | def _escaped(idict):
  function app_arguments_config_arg (line 158) | def app_arguments_config_arg(ap):
  function app_arguments (line 163) | def app_arguments():
  function usage (line 248) | def usage(ap, reason, code=3):
  function parse_config (line 254) | def parse_config(app_args,
  function parse_arguments_and_config (line 268) | def parse_arguments_and_config(app_args,
  function _parse_ps (line 284) | def _parse_ps():
  function _parse_netstat (line 295) | def _parse_netstat():
  function _get_random_port (line 307) | def _get_random_port():
  function get_mailpile_shared_datadir (line 321) | def get_mailpile_shared_datadir():
  function find_mailpile_executable (line 354) | def find_mailpile_executable():
  function get_os_settings (line 369) | def get_os_settings(args):
  function get_user_settings (line 396) | def get_user_settings(args, user=None, mailpiles=None):
  function discover_mailpiles (line 422) | def discover_mailpiles(mailpiles=None):
  function _rewritemap (line 450) | def _rewritemap(mailpiles):
  function parse_rewritemap (line 471) | def parse_rewritemap(args, os_settings, mailpiles=None):
  function save_rewritemap (line 489) | def save_rewritemap(args, os_settings, mailpiles):
  function parse_usermap (line 500) | def parse_usermap(args, os_settings, mailpiles=None):
  function save_usermap (line 504) | def save_usermap(args, os_settings, mailpiles):
  function save_cgi (line 508) | def save_cgi(os_settings):
  function save_apache_sudoers (line 513) | def save_apache_sudoers(os_settings):
  function run_script (line 518) | def run_script(args, settings, script):
  function _get_mailpiles (line 529) | def _get_mailpiles(args, os_settings, discover=False):
  function list_mailpiles (line 538) | def list_mailpiles(args):
  function generate_apache_usermap (line 557) | def generate_apache_usermap(app_args, args):
  function generate_apache_sudoers (line 561) | def generate_apache_sudoers(app_args, args):
  function generate_apache_config (line 564) | def generate_apache_config(app_args, args):
  function configure_apache (line 567) | def configure_apache(app_args, args):
  function configure_apache_usermap (line 582) | def configure_apache_usermap(app_args, args):
  function start_mailpile (line 590) | def start_mailpile(app_args, args):
  function launch_mailpile (line 619) | def launch_mailpile(app_args, args):
  function stop_mailpile (line 627) | def stop_mailpile(app_args, args):
  function delete_mailpile (line 639) | def delete_mailpile(app_args, args):
  function main (line 649) | def main():
  function handle_cgi_post (line 684) | def handle_cgi_post():

FILE: shared-data/multipile/mailpile-launcher.py
  function usage (line 29) | def usage(code, msg=''):