def __init__(self):
    self.parseArgs()
    self.easylists_download_latest()
    self.parse_and_filter_rule_files()
    self.prioritize_rules()
    if not self.my_extra_rules_off:
        self.easylist_append_rules(my_extra_rules)
    if self.debug:
        print("Good rules and strengths:\n" + '\n'.join('{: 5d}:\t{}\t\t[{:2.1f}]'.format(i,r,s) for (i,(r,s)) in enumerate(zip(self.good_rules,self.good_signal))))
        print("\nBad rules and strengths:\n" + '\n'.join('{: 5d}:\t{}\t\t[{:2.1f}]'.format(i,r,s) for (i,(r,s)) in enumerate(zip(self.bad_rules,self.bad_signal))))
        if plot_flag:
            # plt.plot(np.arange(len(self.good_signal)), self.good_signal, '.')
            # plt.show()
            plt.plot(np.arange(len(self.bad_signal)), self.bad_signal, '.')
            plt.xlabel('Rule index')
            plt.ylabel('Bad rule distance (logit)')
            plt.show()
        return
    self.parse_easylist_rules()
    self.create_pac_file()

def parseArgs(self):
    # blackhole specification in arguments
    # best choice is the LAN IP address of the http://hostname/proxy.pac web server or a dedicated blackhole server, e.g. 192.168.0.2:8119
    parser = ap.ArgumentParser()
    parser.add_argument('-b', '--blackhole', help="Blackhole IP:port", type=str, default='127.0.0.1:8119')
    parser.add_argument('-d', '--download-dir', help="Download directory", type=str, default='~/Downloads')
    parser.add_argument('-g', '--debug', help="Debug: Just print rules", action='store_true')
    parser.add_argument('-moff', '--my_extra_rules_turnoff_flag', help="Turn off adding my extra rules", default=False, action='store_true')
    parser.add_argument('-p', '--proxy', help="Proxy host:port", type=str, default='')
    parser.add_argument('-P', '--PAC-original', help="Original proxy.pac file", type=str, default='proxy.pac.orig')
    parser.add_argument('-rb', '--bad-rule-max', help="Maximum number of bad rules (-1 for unlimited)", type=int,
                        default=19999)
    parser.add_argument('-rg', '--good-rule-max', help="Maximum number of good rules (-1 for unlimited)",
                        type=int, default=1099)
    parser.add_argument('-th', '--truncate_hash', help="Truncate hash object length to maximum number", type=int,
                        default=3999)
    parser.add_argument('-tr', '--truncate_regex', help="Truncate regex rules to maximum number", type=int,
                        default=499)
    parser.add_argument('-w', '--sliding-window', help="Sliding window training and test (slow)", action='store_true')
    parser.add_argument('-x', '--Extra_EasyList_URLs', help="Extra Easylsit URLs", type=str, nargs='+', default=[])
    parser.add_argument('-*', '--wildcard-limit', help="Limit the number of wildcards", type=int, default=999)
    parser.add_argument('-@@', '--exceptions_include_flag', help="Include exception rules", action='store_true')
    args = parser.parse_args()
    self.args = parser.parse_args()
    self.blackhole_ip_port = args.blackhole
    self.easylist_dir = os.path.expanduser(args.download_dir)
    self.debug = args.debug
    self.my_extra_rules_off = args.my_extra_rules_turnoff_flag
    self.proxy_host_port = args.proxy
    self.orig_pac_file = os.path.join(self.easylist_dir, args.PAC_original)
    # n.b. negative limits are set to no limits using [:None] slicing trick
    self.good_rule_max = args.good_rule_max if args.good_rule_max >= 0 else None
    self.bad_rule_max = args.bad_rule_max if args.bad_rule_max >= 0 else None
    self.truncate_hash_max = args.truncate_hash if args.truncate_hash >= 0 else None
    self.truncate_alternatives_max = args.truncate_regex if args.truncate_regex >= 0 else None
    self.sliding_window = args.sliding_window
    self.exceptions_include_flag = args.exceptions_include_flag
    self.wildcard_named_group_limit = args.wildcard_limit if args.wildcard_limit >= 0 else None
    self.extra_easylist_urls = args.Extra_EasyList_URLs
    return self.args

def easylists_download_latest(self):
    easylist_url = 'https://easylist.to/easylist/easylist.txt'
    easyprivacy_url = 'https://easylist.to/easylist/easyprivacy.txt'
    fanboy_annoyance_url = 'https://easylist.to/easylist/fanboy-annoyance.txt'
    fanboy_antifacebook = 'https://raw.githubusercontent.com/ryanbr/fanboy-adblock/master/fanboy-antifacebook.txt'
    self.download_list = [fanboy_antifacebook, fanboy_annoyance_url, easyprivacy_url, easylist_url] + self.extra_easylist_urls
    self.file_list = []
    for url in self.download_list:
        fname = os.path.basename(url)
        fname_full = os.path.join(self.easylist_dir, fname)
        file_utc = file_to_utc(fname_full) if os.path.isfile(os.path.join(self.easylist_dir, fname)) else 0.
        resp = urllib.request.urlopen(urllib.request.Request(url, headers={'User-Agent': user_agent}))
        url_utc = last_modified_to_utc(last_modified_resp(resp))
        if (url_utc > file_utc) or (os.path.getsize(fname_full) == 0):  # download the newer file
            with open(fname_full, mode='w', encoding='utf-8') as out_file:
                out_file.write(resp.read().decode('utf-8'))
        self.file_list.append(fname_full)

def parse_and_filter_rule_files(self):
    """Parse all rules into good and bad lists. Use flags to specify included/excluded rules."""
    self.good_rules = []
    self.bad_rules = []
    self.good_opts = []
    self.bad_opts = []
    self.good_rules_include_flag = []
    self.bad_rules_include_flag = []
    for file in self.file_list:
        with open(file, 'r', encoding='utf-8') as fd:
            self.easylist_append_rules(fd)

def easylist_append_rules(self, fd):
    """Append EasyList rules from file to good and bad lists."""
    for line in fd:
        line = line.rstrip()
        try:
            self.easylist_append_one_rule(line)
        except self.RuleIgnored as e:
            if self.debug: print(e,flush=True)
            continue

class RuleIgnored(Exception):
    pass

def easylist_append_one_rule(self, line):
    """Append EasyList rules from line to good and bad lists."""
    ignore_rules_flag = False
    ignored_rules_count = 0
    line_orig = line
    # configuration lines and selector rules should already be filtered out
    if re_test(configuration_re, line) or re_test(selector_re, line): raise self.RuleIgnored("Rule '{}' not added.".format(line))
    exception_flag = exception_filter(line)  # block default; pass if True
    line = exception_re.sub(r'\1', line)
    option_exception_re = not3dimppuposgh_option_exception_re  # ignore these options by default
    # delete all easylist options **prior** to regex and selector cases
    # ignore domain limits for now
    opts = ''  # default: no options in the rule
    if re_test(option_re, line):
        opts = option_re.sub(r'\2', line)
        # domain-specific and other option exceptions: ignore
        # too many rules (>~ 10k) bog down the browser; make reasonable exclusions here
        line = option_re.sub(r'\1', line)  # delete all the options and continue
    # ignore these cases
    # comment case: ignore
    if re_test(comment_re, line):
        if re_test(commentname_sections_ignore_re, line):
            ignored_rules_comment_start = comment_re.sub('', line)
            if not ignore_rules_flag:
                ignored_rules_count = 0
                ignore_rules_flag = True
                print('Ignore rules following comment ', end='', flush=True)
            print('"{}"… '.format(ignored_rules_comment_start), end='', flush=True)
        else:
            if ignore_rules_flag: print('\n {:d} rules ignored.'.format(ignored_rules_count), flush=True)
            ignored_rules_count = 0
            ignore_rules_flag = False
        raise self.RuleIgnored("Rule '{}' not added.".format(line))
    if ignore_rules_flag:
        ignored_rules_count += 1
        self.append_rule(exception_flag, line, opts, False)
        raise self.RuleIgnored("Rule '{}' not added.".format(line))
    # blank url case: ignore
    if re_test(httpempty_re, line): raise self.RuleIgnored("Rule '{}' not added.".format(line))
    # blank line case: ignore
    if not bool(line): raise self.RuleIgnored("Rule '{}' not added.".format(line))
    # block default or pass exception
    if exception_flag:
        option_exception_re = not3dimppuposgh_option_exception_re  # ignore these options within exceptions
        if not self.exceptions_include_flag:
            self.append_rule(exception_flag, line, opts, False)
            raise self.RuleIgnored("Rule '{}' not added.".format(line))
    # specific options: ignore
    if re_test(option_exception_re, opts):
        self.append_rule(exception_flag, line, opts, False)
        raise self.RuleIgnored("Rule '{}' not added.".format(line))
    # add all remaining rules
    self.append_rule(exception_flag, line, opts, True)

def append_rule(self,exception_flag,rule, opts, include_rule_flag):
    if not bool(rule): return  # last chance to reject blank lines -- shouldn't happen
    if exception_flag:
        self.good_rules.append(rule)
        self.good_opts.append(option_tokenizer(opts))
        self.good_rules_include_flag.append(include_rule_flag)
    else:
        self.bad_rules.append(rule)
        self.bad_opts.append(option_tokenizer(opts))
        self.bad_rules_include_flag.append(include_rule_flag)

def good_class_test(self,rule,opts=''):
    return not bool(badregex_regex_filters_re.search(rule))

def bad_class_test(self,rule,opts=''):
    """Bad rule of interest if a match for the bad regex's or specific rule options,

def prioritize_rules(self):
    # use bootstrap regex preferences
    # https://github.com/seatgeek/fuzzywuzzy would be great here if there were such a thing for regex
    self.good_signal = np.array([self.good_class_test(x,opts) for (x,opts,f) in zip(self.good_rules,self.good_opts,self.good_rules_include_flag) if f], dtype=np.int)
    self.bad_signal = np.array([self.bad_class_test(x,opts) for (x,opts,f) in zip(self.bad_rules,self.bad_opts,self.bad_rules_include_flag) if f], dtype=np.int)

    self.good_columns = np.array([i for (i,f) in enumerate(self.good_rules_include_flag) if f],dtype=int)
    self.bad_columns = np.array([i for (i,f) in enumerate(self.bad_rules_include_flag) if f],dtype=int)

    # Logistic Regression for more accurate rule priorities
    if machine_learning_flag:
        print("Performing logistic regression on rule sets. This will take a few minutes…",end='',flush=True)
        self.logreg_priorities()
        print(" done.", flush=True)

        # truncate to positive signal strengths
        if not self.debug:
            self.good_rule_max = min(self.good_rule_max,np.count_nonzero(self.good_signal > 0)) \
                if isinstance(self.good_rule_max,(int,np.int)) else np.count_nonzero(self.good_signal > 0)
            self.bad_rule_max = min(self.bad_rule_max, np.count_nonzero(self.bad_signal > 0)) \
                if isinstance(self.bad_rule_max,(int,np.int)) else np.count_nonzero(self.bad_signal > 0)

    # prioritize and limit the rules
    good_pridx = np.array([e[0] for e in sorted(enumerate(self.good_signal),key=lambda e: e[1],reverse=True)],dtype=int)[:self.good_rule_max]
    self.good_columns = self.good_columns[good_pridx]
    self.good_signal = self.good_signal[good_pridx]
    self.good_rules = [self.good_rules[k] for k in self.good_columns]
    bad_pridx = np.array([e[0] for e in sorted(enumerate(self.bad_signal),key=lambda e: e[1],reverse=True)],dtype=int)[:self.bad_rule_max]
    self.bad_columns = self.bad_columns[bad_pridx]
    self.bad_signal = self.bad_signal[bad_pridx]
    self.bad_rules = [self.bad_rules[k] for k in self.bad_columns]

    # include hardcoded rules
    for rule in include_these_good_rules:
        if rule not in self.good_rules: self.good_rules.append(rule)
    for rule in include_these_bad_rules:
        if rule not in self.bad_rules: self.bad_rules.append(rule)

    # rules are now ordered
    self.good_columns = np.arange(0,len(self.good_rules),dtype=self.good_columns.dtype)
    self.bad_columns = np.arange(0,len(self.bad_rules),dtype=self.bad_columns.dtype)

    return

def logreg_priorities(self):
    """Rule prioritization using logistic regression on bootstrap preferences."""
    self.good_fv_json = {}
    self.good_column_hash = {}
    for col, (rule,opts) in enumerate(zip(self.good_rules,self.good_opts)):
        feature_vector_append_column(rule, opts, col, self.good_fv_json)
        self.good_column_hash[rule] = col
    self.bad_fv_json = {}
    self.bad_column_hash = {}
    for col, (rule,opts) in enumerate(zip(self.bad_rules,self.bad_opts)):
        feature_vector_append_column(rule, opts, col, self.bad_fv_json)
        self.bad_column_hash[rule] = col

    self.good_fv_mat, self.good_row_hash = fv_to_mat(self.good_fv_json, self.good_rules)
    self.bad_fv_mat, self.bad_row_hash = fv_to_mat(self.bad_fv_json, self.bad_rules)

    self.good_X_all = StandardScaler(with_mean=False).fit_transform(self.good_fv_mat.astype(np.float))
    self.good_y_all = np.array([self.good_class_test(x,opts) for (x,opts) in zip(self.good_rules, self.good_opts)], dtype=np.int)

    self.bad_X_all = StandardScaler(with_mean=False).fit_transform(self.bad_fv_mat.astype(np.float))
    self.bad_y_all = np.array([self.bad_class_test(x,opts) for (x,opts) in zip(self.bad_rules, self.bad_opts)], dtype=np.int)

    self.logit_fit_method_sample_weights()

    # inverse regularization signal; smaller values give more sparseness, less model rigidity
    self.C = 1.e1

    self.logreg_test_in_training()
    if self.sliding_window: self.logreg_sliding_window()

    return

def debug_feature_vector(self,rule_substring=r'google.com/pagead'):
    for j, rule in enumerate(self.bad_rules):
        if rule.find(rule_substring) >= 0: break
    col = j
    print(self.bad_rules[col])
    _, rows = self.bad_fv_mat[col,:].nonzero()  # fv_mat is transposed
    print(rows)
    for row in rows:
        print('Row {:d}: {}:: {:g}'.format(row, self.bad_row_hash[int(row)], self.bad_fv_mat[col, row]))

def logit_fit_method_sample_weights(self):
    # weights for LogisticRegression.fit()
    self.good_w_all = np.ones(len(self.good_y_all))
    self.bad_w_all = np.ones(len(self.bad_y_all))

    # add more weight for each of these regex matches
    for i, rule in enumerate(self.bad_rules):
        self.bad_w_all[i] += 1/max(1,len(rule))  # slight disadvantage for longer rules
        for regex in high_weight_regex:
            self.bad_w_all[i] += len(regex.findall(rule))
        # these options have more weight
        self.bad_w_all[i] += bool(thrdp_im_pup_os_option_re.search(self.bad_opts[i]))
    return

def logreg_test_in_training(self):
    """fast, initial method: test vectors in the training data"""

    self.good_fv_logreg = LogisticRegression(C=self.C, penalty='l2', solver='liblinear', tol=0.01)
    self.bad_fv_logreg = LogisticRegression(C=self.C, penalty='l2', solver='liblinear', tol=0.01)

    good_x_test = self.good_X_all[self.good_columns]
    good_X = self.good_X_all
    good_y = self.good_y_all
    good_w = self.good_w_all

    bad_x_test = self.bad_X_all[self.bad_columns]
    bad_X = self.bad_X_all
    bad_y = self.bad_y_all
    bad_w = self.bad_w_all

    if good_x_test.shape[0] > 0:
        self.good_fv_logreg.fit(good_X, good_y, sample_weight=good_w)
        self.good_signal = self.good_fv_logreg.decision_function(good_x_test)
    if bad_x_test.shape[0] > 0:
        self.bad_fv_logreg.fit(bad_X, bad_y, sample_weight=bad_w)
        self.bad_signal = self.bad_fv_logreg.decision_function(bad_x_test)
    return

def logreg_sliding_window(self):
    """bootstrap the signal strengths by removing test vectors from training"""

    # pre-prioritize using test-in-target values and limit the rules
    if not self.debug:
        good_preidx = np.array([e[0] for e in sorted(enumerate(self.good_signal),key=lambda e: e[1],reverse=True)],dtype=int)[:int(np.ceil(1.4*self.good_rule_max))]
        self.good_columns = self.good_columns[good_preidx]
        bad_preidx = np.array([e[0] for e in sorted(enumerate(self.bad_signal),key=lambda e: e[1],reverse=True)],dtype=int)[:int(np.ceil(1.4*self.bad_rule_max))]
        self.bad_columns = self.bad_columns[bad_preidx]

    # multithreaded loop for speed
    use_blocked_not_sklearn_mp = True  # it's a lot faster to block it yourself
    if use_blocked_not_sklearn_mp:
        # init w/ target-in-training results
        good_fv_logreg = copy.deepcopy(self.good_fv_logreg)
        good_fv_logreg.penalty = 'l2'
        good_fv_logreg.solver = 'sag'
        good_fv_logreg.warm_start = True
        good_fv_logreg.n_jobs = 1  # achieve parallelism via block processing
        bad_fv_logreg = copy.deepcopy(self.bad_fv_logreg)
        bad_fv_logreg.penalty = 'l2'
        bad_fv_logreg.solver = 'sag'
        bad_fv_logreg.warm_start = True
        bad_fv_logreg.n_jobs = 1  # achieve parallelism via block processing
        if False:  # debug mp: turn off multiprocessing with a monkeypatch
            class NotAMultiProcess(mp.Process):
                def start(self): self.run()
                def join(self): pass
            mp.Process = NotAMultiProcess

        # this is probably efficient with Linux's copy-on-write fork(); unsure about BSD/macOS
        # must refactor to use shared Array() [along with warm_start coeff's] to ensure
        # see https://stackoverflow.com/questions/5549190/is-shared-readonly-data-copied-to-different-processes-for-python-multiprocessing/

        # distribute training and tests across multiprocessors
        def training_op(queue, X_all, y_all, w_all, fv_logreg, columns, column_block):
            """Training and test operation put into a mp.Queue.
            columns[column_block] and signal[column_block] are the rule columns and corresponding signal strengths
            """
            res = np.zeros(len(column_block))
            for k in range(len(column_block)):
                mask = np.zeros(len(y_all), dtype=bool)
                mask[columns[column_block[k]]] = True
                mask = np.logical_not(mask)

                x_test = X_all[np.logical_not(mask)]
                X = X_all[mask]
                y = y_all[mask]
                w = w_all[mask]

                fv_logreg.fit(X, y, sample_weight=w)
                res[k] = fv_logreg.decision_function(x_test)[0]
            queue.put((column_block,res))  # signal[column_block] = res
            return

        num_threads = mp.cpu_count()

        # good
        q = mp.Queue()
        jobs = []
        self.good_signal = np.zeros(len(self.good_columns))
        block_length = len(self.good_columns) // num_threads
        column_block = np.arange(0, block_length)
        while len(column_block) > 0:
            column_block = column_block[np.where(column_block < len(self.good_columns))]
            fv_logreg = copy.deepcopy(good_fv_logreg)  # each process gets its own .coeff_'s
            column_block_copy = np.copy(column_block)  # each process gets its own block of columns
            p = mp.Process(target=training_op, args=(q, self.good_X_all, self.good_y_all, self.good_w_all, fv_logreg, self.good_columns, column_block_copy))
            p.start()
            jobs.append(p)
            column_block += len(column_block)
        # process the results in the queue
        for i in range(len(jobs)):
            column_block, res = q.get()
            self.good_signal[column_block] = res
        # join all jobs and wait for them to complete
        for p in jobs: p.join()

        # bad
        q = mp.Queue()
        jobs = []
        self.bad_signal = np.zeros(len(self.bad_columns))
        block_length = len(self.bad_columns) // num_threads
        column_block = np.arange(0, block_length)
        while len(column_block) > 0:
            column_block = column_block[np.where(column_block < len(self.bad_columns))]
            fv_logreg = copy.deepcopy(bad_fv_logreg)   # each process gets its own .coeff_'s
            column_block_copy = np.copy(column_block)  # each process gets its own block of columns
            p = mp.Process(target=training_op, args=(q, self.bad_X_all, self.bad_y_all, self.bad_w_all, fv_logreg, self.bad_columns, column_block_copy))
            p.start()
            jobs.append(p)
            column_block += len(column_block)
        # process the results in the queue
        for i in range(len(jobs)):
            column_block, res = q.get()
            self.bad_signal[column_block] = res
        # join all jobs and wait for them to complete
        for p in jobs: p.join()
    else:  # if use_blocked_not_sklearn_mp:
        def training_op(X_all, y_all, w_all, fv_logreg, columns, signal):
            """Training and test operations reusing results with multiprocessing."""
            res = np.zeros(len(signal))
            for k in range(len(res)):
                mask = np.zeros(len(y_all), dtype=bool)
                mask[columns[k]] = True
                mask = np.logical_not(mask)

                x_test = X_all[np.logical_not(mask)]
                X = X_all[mask]
                y = y_all[mask]
                w = w_all[mask]

                fv_logreg.fit(X, y, sample_weight=w)
                res[k] = fv_logreg.decision_function(x_test)[0]
            signal[:] = res
            return
        # good
        training_op(self.good_X_all, self.good_y_all, self.good_w_all, self.good_fv_logreg, self.good_columns, self.good_signal)
        # bad
        training_op(self.bad_X_all, self.bad_y_all, self.bad_w_all, self.bad_fv_logreg, self.bad_columns, self.bad_signal)
    return

def parse_easylist_rules(self):
    for rule in self.good_rules: self.easylist_to_javascript_vars(rule)
    for rule in self.bad_rules: self.easylist_to_javascript_vars(rule)
    ordered_unique_all_js_var_lists()
    return

def easylist_to_javascript_vars(self,rule,ignore_huge_url_regex_rule_list=False):
    rule = rule.rstrip()
    rule_orig = rule
    exception_flag = exception_filter(rule)  # block default; pass if True
    rule = exception_re.sub(r'\1', rule)
    option_exception_re = not3dimppuposgh_option_exception_re  # ignore these options by default
    opts = ''  # default: no options in the rule
    if re_test(option_re, rule):
        opts = option_re.sub(r'\2', rule)
        # domain-specific and other option exceptions: ignore
        # too many rules (>~ 10k) bog down the browser; make reasonable exclusions here
        rule = option_re.sub(r'\1', rule)  # delete all the options and continue
    # ignore these cases
    # comment case: ignore
    if re_test(comment_re, rule): return
    # block default or pass exception
    if exception_flag:
        option_exception_re = not3dimppuposgh_option_exception_re  # ignore these options within exceptions
        if not self.exceptions_include_flag: return
    # specific options: ignore
    if re_test(option_exception_re, opts): return
    # blank url case: ignore
    if re_test(httpempty_re, rule): return
    # blank line case: ignore
    if not rule: return
    # treat each of the these cases separately, here and in Javascript
    # regex case
    if re_test(regex_re, rule):
        if regex_ignore_test(rule): return
        rule = regex_re.sub(r'\1', rule)
        if exception_flag:
            good_url_regex.append(rule)
        else:
            if not re_test(badregex_regex_filters_re,
                           rule): return  # limit bad regex's to those in the filter
            bad_url_regex.append(rule)
        return
    # now that regex's are handled, delete unnecessary wildcards, e.g. /.../*
    rule = wildcard_begend_re.sub(r'\1', rule)
    # domain anchors, || or '|http://a.b' -> domain anchor 'a.b' for regex efficiency in JS
    if re_test(domain_anch_re, rule) or re_test(scheme_anchor_re, rule):
        # strip off initial || or |scheme://
        if re_test(domain_anch_re, rule):
            rule = domain_anch_re.sub(r'\1', rule)
        elif re_test(scheme_anchor_re, rule):
            rule = scheme_anchor_re.sub("", rule)
        # host subcase
        if re_test(da_hostonly_re, rule):
            rule = da_hostonly_re.sub(r'\1', rule)
            if not re_test(wild_anch_sep_exc_re, rule):  # exact subsubcase
                if not re_test(badregex_regex_filters_re, rule):
                    return  # limit bad regex's to those in the filter
                if exception_flag:
                    good_da_host_exact.append(rule)
                else:
                    bad_da_host_exact.append(rule)
                return
            else:  # regex subsubcase
                if regex_ignore_test(rule): return
                if exception_flag:
                    good_da_host_regex.append(rule)
                else:
                    if not re_test(badregex_regex_filters_re,
                                   rule): return  # limit bad regex's to those in the filter
                    bad_da_host_regex.append(rule)
                return
        # hostpath subcase
        if re_test(da_hostpath_re, rule):
            rule = da_hostpath_re.sub(r'\1', rule)
            if not re_test(wild_sep_exc_noanch_re, rule) and re_test(pathend_re, rule):  # exact subsubcase
                rule = re.sub(r'\|$', '', rule)  # strip EOL anchors
                if not re_test(badregex_regex_filters_re, rule):
                    return  # limit bad regex's to those in the filter
                if exception_flag:
                    good_da_hostpath_exact.append(rule)
                else:
                    bad_da_hostpath_exact.append(rule)
                return
            else:  # regex subsubcase
                if regex_ignore_test(rule): return
                # ignore option rules for some regex rules
                if re_test(alloption_exception_re, opts): return
                if exception_flag:
                    good_da_hostpath_regex.append(rule)
                else:
                    if not re_test(badregex_regex_filters_re,
                                   rule): return  # limit bad regex's to those in the filter
                    bad_da_hostpath_regex.append(rule)
                return
        # hostpathquery default case
        if True:
            # if re_test(re.compile(r'^go\.'),rule):
            #     pass
            if regex_ignore_test(rule): return
            if exception_flag:
                good_da_regex.append(rule)
            else:
                bad_da_regex.append(rule)
            return
    # all other non-regex patterns
    if True:
        if regex_ignore_test(rule): return
        if not ignore_huge_url_regex_rule_list:
            if re_test(alloption_exception_re, opts): return
            if exception_flag:
                good_url_parts.append(rule)
            else:
                if not re_test(badregex_regex_filters_re,
                               rule): return  # limit bad regex's to those in the filter
                bad_url_parts.append(rule)
            return  # superfluous return

def create_pac_file(self):
    self.proxy_pac_init()
    self.proxy_pac = self.proxy_pac_preamble \
                + "\n".join(["// " + l for l in self.easylist_strategy.split("\n")]) \
                + self.js_init_object('good_da_host_exact') \
                + self.js_init_regexp('good_da_host_regex', True) \
                + self.js_init_object('good_da_hostpath_exact') \
                + self.js_init_regexp('good_da_hostpath_regex', True) \
                + self.js_init_regexp('good_da_regex', True) \
                + self.js_init_object('good_da_host_exceptions_exact') \
                + self.js_init_object('bad_da_host_exact') \
                + self.js_init_regexp('bad_da_host_regex', True) \
                + self.js_init_object('bad_da_hostpath_exact') \
                + self.js_init_regexp('bad_da_hostpath_regex', True) \
                + self.js_init_regexp('bad_da_regex', True) \
                + self.js_init_regexp('good_url_parts') \
                + self.js_init_regexp('bad_url_parts') \
                + self.js_init_regexp('good_url_regex', regex_flag=True) \
                + self.js_init_regexp('bad_url_regex', regex_flag=True) \
                + self.proxy_pac_postamble

    for l in ['good_da_host_exact',
              'good_da_host_regex',
              'good_da_hostpath_exact',
              'good_da_hostpath_regex',
              'good_da_regex',
              'good_da_host_exceptions_exact',
              'bad_da_host_exact',
              'bad_da_host_regex',
              'bad_da_hostpath_exact',
              'bad_da_hostpath_regex',
              'bad_da_regex',
              'good_url_parts',
              'bad_url_parts',
              'good_url_regex',
              'bad_url_regex']:
        print("{}: {:d} rules".format(l, len(globals()[l])), flush=True)

    with open(os.path.join(self.easylist_dir, 'proxy.pac'), 'w', encoding='utf-8') as fd:
        fd.write(self.proxy_pac)

def proxy_pac_init(self):
    self.pac_proxy = 'PROXY {}'.format(self.proxy_host_port) if self.proxy_host_port else 'DIRECT'

    # define a default, user-supplied FindProxyForURL function
    self.default_FindProxyForURL_function = '''\

    if os.path.isfile(self.orig_pac_file):
        with open(self.orig_pac_file, 'r', encoding='utf-8') as fd:
            self.original_FindProxyForURL_function = fd.read()
    else:
        self.original_FindProxyForURL_function = self.default_FindProxyForURL_function

    # change last 'return "PROXY ..."' to 'return EasyListFindProxyForURL(url, host)'
    def re_sub_last(pattern, repl, string, **kwargs): 
        '''re.sub on the last match in a string'''
        # ensure that pattern is grouped
        # (note that (?:) is not caught)
        pattern_grouped = pattern if bool(re.match(r'\(.+\)',pattern)) else r'({})'.format(pattern)
        spl = re.split(pattern_grouped, string, **kwargs) 
        if len(spl) == 1: return string 
        spl[-2] = re.sub(pattern, repl, spl[-2], **kwargs)
        return ''.join(spl)
    self.original_FindProxyForURL_function = re_sub_last(r'return[\s]+"PROXY[^"]+"', 'return EasyListFindProxyForURL(url, host)',
                                           self.original_FindProxyForURL_function)

    #  proxy.pac preamble
    self.calling_command = ' '.join([os.path.basename(sys.argv[0])] + sys.argv[1:])
    self.proxy_pac_preamble = '''\

    self.proxy_pac_postamble = '''

if (ipv4_pentary) {
    is_valid_ipv4 = true;
    for( i = 1; i <= 4; i++) {
        if (ipv4_pentary[i] >= 256) {
            is_valid_ipv4 = false;
        }
    }
}
return is_valid_ipv4;

alert_flag && alert("url is: " + url);
alert_flag && alert("host is: " + host);

// Extract scheme and url without scheme
var scheme = url.match(schemepart_RegExp)
scheme = scheme.length > 0? scheme[1] : "";

// Remove the scheme and extract the path for regex efficiency
var url_noscheme = url.replace(schemepart_RegExp,"");
var url_pathonly = url_noscheme.replace(hostpart_RegExp,"");
var url_noquery = url_noscheme.replace(querypart_RegExp,"$1");
// Remove the server name from the url and host if host is not an IPv4 address
var url_noserver = !host_is_ipv4 ? url_noscheme.replace(domainpart_RegExp,"$1") : url_noscheme;
var url_noservernoquery = !host_is_ipv4 ? url_noquery.replace(domainpart_RegExp,"$1") : url_noscheme;
var host_noserver =  !host_is_ipv4 ? host.replace(domainpart_RegExp,"$1") : host;

// Debugging results
if (debug_flag && alert_flag) {
    alert("url_noscheme is: " + url_noscheme);
    alert("url_pathonly is: " + url_pathonly);
    alert("url_noquery is: " + url_noquery);
    alert("url_noserver is: " + url_noserver);
    alert("url_noservernoquery is: " + url_noservernoquery);
    alert("host_noserver is: " + host_noserver);
}

// Short circuit to blackhole for good_da_host_exceptions
if ( hasOwnProperty(good_da_host_exceptions_exact_JSON,host) ) {
    alert_flag && alert("good_da_host_exceptions_exact_JSON blackhole!");
    return blackhole;
}

///////////////////////////////////////////////////////////////////////
// Check to make sure we can get an IPv4 address from the given host //
// name.  If we cannot do that then skip the Networks tests.         //
///////////////////////////////////////////////////////////////////////

host_ipv4_address = host_is_ipv4 ? host : (isResolvable(host) ? dnsResolve(host) : false);

if (host_ipv4_address) {
    alert_flag && alert("host ipv4 address is: " + host_ipv4_address);
    /////////////////////////////////////////////////////////////////////////////
    // If the IP translates to one of the GoodNetworks_Array (with exceptions) //
    // we pass it because it is considered safe.                               //
    /////////////////////////////////////////////////////////////////////////////

    for (i in GoodNetworks_Exceptions_Array) {
        tmpNet = GoodNetworks_Exceptions_Array[i].split(/,\s*/);
        if (isInNet(host_ipv4_address, tmpNet[0], tmpNet[1])) {
            alert_flag && alert("GoodNetworks_Exceptions_Array Blackhole: " + host_ipv4_address);
            return blackhole;
        }
    }
    for (i in GoodNetworks_Array) {
        tmpNet = GoodNetworks_Array[i].split(/,\s*/);
        if (isInNet(host_ipv4_address, tmpNet[0], tmpNet[1])) {
            alert_flag && alert("GoodNetworks_Array PASS: " + host_ipv4_address);
            return proxy;
        }
    }

    ///////////////////////////////////////////////////////////////////////
    // If the IP translates to one of the BadNetworks_Array we fail it   //
    // because it is not considered safe.                                //
    ///////////////////////////////////////////////////////////////////////

    for (i in BadNetworks_Array) {
        tmpNet = BadNetworks_Array[i].split(/,\s*/);
        if (isInNet(host_ipv4_address, tmpNet[0], tmpNet[1])) {
            alert_flag && alert("BadNetworks_Array Blackhole: " + host_ipv4_address);
            return blackhole;
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// HTTPS: https scheme can only use domain information                      //
// unless PacHttpsUrlStrippingEnabled == false [Chrome] or                  //
// network.proxy.autoconfig_url.include_path == true [Firefox, about:config]              //
// E.g. on macOS:                                                           //
// defaults write com.google.Chrome PacHttpsUrlStrippingEnabled -bool false //
// Check setting at page chrome://policy                                    //
//////////////////////////////////////////////////////////////////////////////

// Assume browser has disabled path access if scheme is https and path is '/'
if ( scheme == "https" && url_pathonly == "/" ) {

    ///////////////////////////////////////////////////////////////////////
    // PASS LIST:   domains matched here will always be allowed.         //
    ///////////////////////////////////////////////////////////////////////

    if ( (good_da_host_exact_flag && (hasOwnProperty(good_da_host_exact_JSON,host_noserver)||hasOwnProperty(good_da_host_exact_JSON,host)))
        && !hasOwnProperty(good_da_host_exceptions_exact_JSON,host) ) {
            alert_flag && alert("HTTPS PASS: " + host + ", " + host_noserver);
        return proxy;
    }

    //////////////////////////////////////////////////////////
    // BLOCK LIST:	stuff matched here here will be blocked //
    //////////////////////////////////////////////////////////

    if ( (bad_da_host_exact_flag && (hasOwnProperty(bad_da_host_exact_JSON,host_noserver)||hasOwnProperty(bad_da_host_exact_JSON,host))) ) {
        alert_flag && alert("HTTPS blackhole: " + host + ", " + host_noserver);
        return blackhole;
    }
}

////////////////////////////////////////
// HTTPS and HTTP: full path analysis //
////////////////////////////////////////

if (scheme == "https" || scheme == "http") {

    ///////////////////////////////////////////////////////////////////////
    // PASS LIST:   domains matched here will always be allowed.         //
    ///////////////////////////////////////////////////////////////////////

    if ( !hasOwnProperty(good_da_host_exceptions_exact_JSON,host)
        && ((good_da_host_exact_flag && (hasOwnProperty(good_da_host_exact_JSON,host_noserver)||hasOwnProperty(good_da_host_exact_JSON,host))) ||  // fastest test first
            (use_pass_rules_parts_flag &&
                (good_da_hostpath_exact_flag && (hasOwnProperty(good_da_hostpath_exact_JSON,url_noservernoquery)||hasOwnProperty(good_da_hostpath_exact_JSON,url_noquery)) ) ||
                // test logic: only do the slower test if the host has a (non)suspect fqdn
                (good_da_host_regex_flag && (good_da_host_regex_RegExp.test(host_noserver)||good_da_host_regex_RegExp.test(host))) ||
                (good_da_hostpath_regex_flag && (good_da_hostpath_regex_RegExp.test(url_noservernoquery)||good_da_hostpath_regex_RegExp.test(url_noquery))) ||
                (good_da_regex_flag && (good_da_regex_RegExp.test(url_noserver)||good_da_regex_RegExp.test(url_noscheme))) ||
                (good_url_parts_flag && good_url_parts_RegExp.test(url)) ||
                (good_url_regex_flag && good_url_regex_RegExp.test(url)))) ) {
        return proxy;
    }

    //////////////////////////////////////////////////////////
    // BLOCK LIST:	stuff matched here here will be blocked //
    //////////////////////////////////////////////////////////
    // Debugging results
    if (debug_flag && alert_flag) {
        alert("hasOwnProperty(bad_da_host_exact_JSON," + host_noserver + "): " + (bad_da_host_exact_flag && hasOwnProperty(bad_da_host_exact_JSON,host_noserver)));
        alert("hasOwnProperty(bad_da_host_exact_JSON," + host + "): " + (bad_da_host_exact_flag && hasOwnProperty(bad_da_host_exact_JSON,host)));
        alert("hasOwnProperty(bad_da_hostpath_exact_JSON," + url_noservernoquery + "): " + (bad_da_hostpath_exact_flag && hasOwnProperty(bad_da_hostpath_exact_JSON,url_noservernoquery)));
        alert("hasOwnProperty(bad_da_hostpath_exact_JSON," + url_noquery + "): " + (bad_da_hostpath_exact_flag && hasOwnProperty(bad_da_hostpath_exact_JSON,url_noquery)));
        alert("bad_da_host_regex_RegExp.test(" + host_noserver + "): " + (bad_da_host_regex_flag && bad_da_host_regex_RegExp.test(host_noserver)));
        alert("bad_da_host_regex_RegExp.test(" + host + "): " + (bad_da_host_regex_flag && bad_da_host_regex_RegExp.test(host)));
        alert("bad_da_hostpath_regex_RegExp.test(" + url_noservernoquery + "): " + (bad_da_hostpath_regex_flag && bad_da_hostpath_regex_RegExp.test(url_noservernoquery)));
        alert("bad_da_hostpath_regex_RegExp.test(" + url_noquery + "): " + (bad_da_hostpath_regex_flag && bad_da_hostpath_regex_RegExp.test(url_noquery)));
        alert("bad_da_regex_RegExp.test(" + url_noserver + "): " + (bad_da_regex_flag && bad_da_regex_RegExp.test(url_noserver)));
        alert("bad_da_regex_RegExp.test(" + url_noscheme + "): " + (bad_da_regex_flag && bad_da_regex_RegExp.test(url_noscheme)));
        alert("bad_url_parts_RegExp.test(" + url + "): " + (bad_url_parts_flag && bad_url_parts_RegExp.test(url)));
        alert("bad_url_regex_RegExp.test(" + url + "): " + (bad_url_regex_flag && bad_url_regex_RegExp.test(url)));
    }

    if ( (bad_da_host_exact_flag && (hasOwnProperty(bad_da_host_exact_JSON,host_noserver)||hasOwnProperty(bad_da_host_exact_JSON,host))) ||  // fastest test first
        (bad_da_hostpath_exact_flag && (hasOwnProperty(bad_da_hostpath_exact_JSON,url_noservernoquery)||hasOwnProperty(bad_da_hostpath_exact_JSON,url_noquery)) ) ||
        // test logic: only do the slower test if the host has a (non)suspect fqdn
        (bad_da_host_regex_flag && (bad_da_host_regex_RegExp.test(host_noserver)||bad_da_host_regex_RegExp.test(host))) ||
        (bad_da_hostpath_regex_flag && (bad_da_hostpath_regex_RegExp.test(url_noservernoquery)||bad_da_hostpath_regex_RegExp.test(url_noquery))) ||
        (bad_da_regex_flag && (bad_da_regex_RegExp.test(url_noserver)||bad_da_regex_RegExp.test(url_noscheme))) ||
        (bad_url_parts_flag && bad_url_parts_RegExp.test(url)) ||
        (bad_url_regex_flag && bad_url_regex_RegExp.test(url)) ) {
        alert_flag && alert("Blackhole: " + url + ", " + host);
        return blackhole;
    }
}

// default pass
alert_flag && alert("Default PASS: " + url + ", " + host);
return proxy;

    self.easylist_strategy = """\

Traceback (most recent call last):
  File "easylist_pac.py", line 2270, in <module>
    res = EasyListPAC()
  File "easylist_pac.py", line 63, in __init__
    self.prioritize_rules()
  File "easylist_pac.py", line 252, in prioritize_rules
    self.logreg_priorities()
  File "easylist_pac.py", line 312, in logreg_priorities
    if self.sliding_window: self.logreg_sliding_window()
  File "easylist_pac.py", line 432, in logreg_sliding_window
    p.start()
  File "C:\Program Files\Python37\lib\multiprocessing\process.py", line 112, in start
    self._popen = self._Popen(self)
  File "C:\Program Files\Python37\lib\multiprocessing\context.py", line 223, in _Popen
    return _default_context.get_context().Process._Popen(process_obj)
  File "C:\Program Files\Python37\lib\multiprocessing\context.py", line 322, in _Popen
    return Popen(process_obj)
  File "C:\Program Files\Python37\lib\multiprocessing\popen_spawn_win32.py", line 89, in __init__
    reduction.dump(process_obj, to_child)
  File "C:\Program Files\Python37\lib\multiprocessing\reduction.py", line 60, in dump
    ForkingPickler(file, protocol).dump(obj)
AttributeError: Can't pickle local object 'EasyListPAC.logreg_sliding_window.<locals>.training_op'

easylist_pac.py:50: MatplotlibDeprecationWarning: Support for setting the 'text.latex.preamble' or 'pgf.preamble' rcParam to a list of strings is deprecated since 3.3 and will be removed two minor releases later; set it to a single string instead.
  mpl.rcParams['text.latex.preamble'] = [r'\\usepackage{amsmath,sfmath} \\boldmath']

No module named 'sklearn'
easylist_pac.py:32: UserWarning: Install scikit-learn for more accurate EasyList rule selection.
  warnings.warn("Install scikit-learn for more accurate EasyList rule selection.")

Traceback (most recent call last):
  File "easylist_pac.py", line 27, in <module>
    from sklearn.linear_model import LogisticRegression
  File "/usr/lib64/python3.5/site-packages/sklearn/linear_model/__init__.py", line 15, in <module>
    from .least_angle import (Lars, LassoLars, lars_path, LarsCV, LassoLarsCV,
  File "/usr/lib64/python3.5/site-packages/sklearn/linear_model/least_angle.py", line 19, in <module>
    from scipy import linalg, interpolate
  File "/usr/lib64/python3.5/site-packages/scipy/interpolate/__init__.py", line 175, in <module>
    from .interpolate import *
  File "/usr/lib64/python3.5/site-packages/scipy/interpolate/interpolate.py", line 32, in <module>
    from .interpnd import _ndim_coords_from_arrays
  File "interpnd.pyx", line 1, in init scipy.interpolate.interpnd
  File "/usr/lib64/python3.5/site-packages/scipy/spatial/__init__.py", line 95, in <module>
    from .qhull import *
  File "qhull.pyx", line 2155, in init scipy.spatial.qhull
AttributeError: 'cython_function_or_method' object has no attribute '__func__'

Traceback (most recent call last):
  File "easylist_pac.py", line 27, in <module>
    from sklearn.linear_model import LogisticRegression
  File "/usr/lib64/python3.5/site-packages/sklearn/__init__.py", line 57, in <module>
    from .base import clone
  File "/usr/lib64/python3.5/site-packages/sklearn/base.py", line 12, in <module>
    from .utils.fixes import signature
  File "/usr/lib64/python3.5/site-packages/sklearn/utils/__init__.py", line 11, in <module>
    from .validation import (as_float_array,
  File "/usr/lib64/python3.5/site-packages/sklearn/utils/validation.py", line 18, in <module>
    from ..utils.fixes import signature
  File "/usr/lib64/python3.5/site-packages/sklearn/utils/fixes.py", line 403, in <module>
    from scipy.stats import rankdata
  File "/usr/lib64/python3.5/site-packages/scipy/stats/__init__.py", line 343, in <module>
    from .stats import *
  File "/usr/lib64/python3.5/site-packages/scipy/stats/stats.py", line 171, in <module>
    from . import distributions
  File "/usr/lib64/python3.5/site-packages/scipy/stats/distributions.py", line 10, in <module>
    from ._distn_infrastructure import (entropy, rv_discrete, rv_continuous,
  File "/usr/lib64/python3.5/site-packages/scipy/stats/_distn_infrastructure.py", line 16, in <module>
    from scipy.misc import doccer
  File "/usr/lib64/python3.5/site-packages/scipy/misc/__init__.py", line 67, in <module>
    from scipy.interpolate._pade import pade as _pade
  File "/usr/lib64/python3.5/site-packages/scipy/interpolate/__init__.py", line 175, in <module>
    from .interpolate import *
  File "/usr/lib64/python3.5/site-packages/scipy/interpolate/interpolate.py", line 32, in <module>
    from .interpnd import _ndim_coords_from_arrays
  File "interpnd.pyx", line 1, in init scipy.interpolate.interpnd
  File "/usr/lib64/python3.5/site-packages/scipy/spatial/__init__.py", line 95, in <module>
    from .qhull import *
  File "qhull.pyx", line 2155, in init scipy.spatial.qhull
AttributeError: 'cython_function_or_method' object has no attribute '__func__'

Traceback (most recent call last):
  File "easylist_pac.py", line 27, in <module>
    from sklearn.linear_model import LogisticRegression
  File "/usr/lib64/python3.5/site-packages/sklearn/linear_model/__init__.py", line 12, in <module>
    from .base import LinearRegression
  File "/usr/lib64/python3.5/site-packages/sklearn/linear_model/base.py", line 38, in <module>
    from ..preprocessing.data import normalize as f_normalize
  File "/usr/lib64/python3.5/site-packages/sklearn/preprocessing/__init__.py", line 8, in <module>
    from .data import Binarizer
  File "/usr/lib64/python3.5/site-packages/sklearn/preprocessing/data.py", line 18, in <module>
    from scipy import stats
  File "/usr/lib64/python3.5/site-packages/scipy/stats/__init__.py", line 343, in <module>
    from .stats import *
  File "/usr/lib64/python3.5/site-packages/scipy/stats/stats.py", line 171, in <module>
    from . import distributions
  File "/usr/lib64/python3.5/site-packages/scipy/stats/distributions.py", line 10, in <module>
    from ._distn_infrastructure import (entropy, rv_discrete, rv_continuous,
  File "/usr/lib64/python3.5/site-packages/scipy/stats/_distn_infrastructure.py", line 16, in <module>
    from scipy.misc import doccer
  File "/usr/lib64/python3.5/site-packages/scipy/misc/__init__.py", line 67, in <module>
    from scipy.interpolate._pade import pade as _pade
  File "/usr/lib64/python3.5/site-packages/scipy/interpolate/__init__.py", line 175, in <module>
    from .interpolate import *
  File "/usr/lib64/python3.5/site-packages/scipy/interpolate/interpolate.py", line 32, in <module>
    from .interpnd import _ndim_coords_from_arrays
  File "interpnd.pyx", line 1, in init scipy.interpolate.interpnd
  File "/usr/lib64/python3.5/site-packages/scipy/spatial/__init__.py", line 95, in <module>
    from .qhull import *
  File "qhull.pyx", line 2155, in init scipy.spatial.qhull
AttributeError: 'cython_function_or_method' object has no attribute '__func__'

eselect cblas list
Installed CBLAS for library directory lib64
  [1]   gsl *
  [2]   reference