Merge changes from topics "coreapi-flag", "coreapi-stubs-csv"

FLAG_BLACKLIST = "blacklist"

FLAG_GREYLIST_MAX_O = "greylist-max-o"

FLAG_GREYLIST_MAX_P = "greylist-max-p"

FLAG_CORE_PLATFORM_API = "core-platform-api"

# List of all known flags.

FLAGS = [

FLAGS_API_LIST = [

    FLAG_WHITELIST,

    FLAG_GREYLIST,

    FLAG_BLACKLIST,

    FLAG_GREYLIST_MAX_O,

    FLAG_GREYLIST_MAX_P,

]

FLAGS_SET = set(FLAGS)

ALL_FLAGS = FLAGS_API_LIST + [ FLAG_CORE_PLATFORM_API ]

FLAGS_API_LIST_SET = set(FLAGS_API_LIST)

ALL_FLAGS_SET = set(ALL_FLAGS)

# Suffix used in command line args to express that only known and

# otherwise unassigned entries should be assign the given flag.

SERIALIZATION_REGEX = re.compile(r'.*->(' + '|'.join(SERIALIZATION_PATTERNS) + r')$')

# Predicates to be used with filter_apis.

IS_UNASSIGNED = lambda api, flags: not flags

HAS_NO_API_LIST_ASSIGNED = lambda api, flags: not FLAGS_API_LIST_SET.intersection(flags)

IS_SERIALIZATION = lambda api, flags: SERIALIZATION_REGEX.match(api)

def get_args():

    parser.add_argument('--csv', nargs='*', default=[], metavar='CSV_FILE',

        help='CSV files to be merged into output')

    for flag in FLAGS:

    for flag in ALL_FLAGS:

        ignore_conflicts_flag = flag + FLAG_IGNORE_CONFLICTS_SUFFIX

        parser.add_argument('--' + flag, dest=flag, nargs='*', default=[], metavar='TXT_FILE',

            help='lists of entries with flag "' + flag + '"')

    def _check_flags_set(self, flags_subset, source):

        assert isinstance(flags_subset, set)

        assert flags_subset.issubset(FLAGS_SET), (

        assert flags_subset.issubset(ALL_FLAGS_SET), (

            "Error processing: {}\n"

            "The following flags were not recognized: \n"

            "{}\n"

            "Please visit go/hiddenapi for more information.").format(

                source, "\n".join(flags_subset - FLAGS_SET))

                source, "\n".join(flags_subset - ALL_FLAGS_SET))

    def filter_apis(self, filter_fn):

        """Returns APIs which match a given predicate.

    def get_valid_subset_of_unassigned_apis(self, api_subset):

        """Sanitizes a key set input to only include keys which exist in the dictionary

        and have not been assigned any flags.

        and have not been assigned any API list flags.

        Args:

            entries_subset (set/list): Key set to be sanitized.

            Sanitized key set.

        """

        assert isinstance(api_subset, set)

        return api_subset.intersection(self.filter_apis(IS_UNASSIGNED))

        return api_subset.intersection(self.filter_apis(HAS_NO_API_LIST_ASSIGNED))

    def generate_csv(self):

        """Constructs CSV entries from a dictionary.

        """Assigns a flag to given subset of entries.

        Args:

            flag (string): One of FLAGS.

            flag (string): One of ALL_FLAGS.

            apis (set): Subset of APIs to recieve the flag.

            source (string): Origin of `entries_subset`. Will be printed in error messages.

    flags.assign_flag(FLAG_WHITELIST, flags.filter_apis(IS_SERIALIZATION))

    # (2) Merge text files with a known flag into the dictionary.

    for flag in FLAGS:

    for flag in ALL_FLAGS:

        for filename in args[flag]:

            flags.assign_flag(flag, read_lines(filename), filename)

    # (a) the entry exists, and

    # (b) it has not been assigned any other flag.

    # Because of (b), this must run after all strict assignments have been performed.

    for flag in FLAGS:

    for flag in ALL_FLAGS:

        for filename in args[flag + FLAG_IGNORE_CONFLICTS_SUFFIX]:

            valid_entries = flags.get_valid_subset_of_unassigned_apis(read_lines(filename))

            flags.assign_flag(flag, valid_entries, filename)

    # Assign all remaining entries to the blacklist.

    flags.assign_flag(FLAG_BLACKLIST, flags.filter_apis(IS_UNASSIGNED))

    flags.assign_flag(FLAG_BLACKLIST, flags.filter_apis(HAS_NO_API_LIST_ASSIGNED))

    # Write output.

    write_lines(args["output"], flags.generate_csv())