示例#1
0
 def create_hierarchy(hierarchy, parent=None, level=0):
     """Create hierarchy."""
     result = {}
     for name, children in hierarchy.items():
         node = hierarchy_utils.TreeNode(name, parent)
         node.children = create_hierarchy(children, node, level + 1)
         node.classification_path = [pn.name for pn in node.get_path()]
         node.classification_name = taxonomy.recombine_classification_from_hierarchy(node.classification_path)
         hierarchy_lookup[node.classification_name] = node
         result[node.name] = node
     classifications = natsort.natsorted(result.keys(), alg=natsort.ns.F | natsort.ns.IC)
     taxonomy.sort_classifications(classifications, lang, level=level)
     return [result[classification] for classification in classifications]
示例#2
0
    def _do_classification(self, site):
        # Needed to avoid strange errors during tests
        if site is not self.site:
            return

        # Get list of enabled taxonomy plugins and initialize data structures
        taxonomies = site.taxonomy_plugins.values()
        site.posts_per_classification = {}
        for taxonomy in taxonomies:
            site.posts_per_classification[taxonomy.classification_name] = {
                lang: defaultdict(set)
                for lang in site.config['TRANSLATIONS'].keys()
            }

        # Classify posts
        for post in site.timeline:
            # Do classify pages, but don’t classify posts that are hidden
            # (draft/private/future)
            if post.is_post and not post.use_in_feeds:
                continue
            for taxonomy in taxonomies:
                if taxonomy.apply_to_posts if post.is_post else taxonomy.apply_to_pages:
                    classifications = {}
                    for lang in site.config['TRANSLATIONS'].keys():
                        # Extract classifications for this language
                        classifications[lang] = taxonomy.classify(post, lang)
                        if not taxonomy.more_than_one_classifications_per_post and len(
                                classifications[lang]) > 1:
                            raise ValueError(
                                "Too many {0} classifications for post {1}".
                                format(taxonomy.classification_name,
                                       post.source_path))
                        # Add post to sets
                        for classification in classifications[lang]:
                            while True:
                                site.posts_per_classification[
                                    taxonomy.classification_name][lang][
                                        classification].add(post)
                                if not taxonomy.include_posts_from_subhierarchies or not taxonomy.has_hierarchy:
                                    break
                                classification_path = taxonomy.extract_hierarchy(
                                    classification)
                                if len(classification_path) <= 1:
                                    if len(
                                            classification_path
                                    ) == 0 or not taxonomy.include_posts_into_hierarchy_root:
                                        break
                                classification = taxonomy.recombine_classification_from_hierarchy(
                                    classification_path[:-1])

        # Sort everything.
        site.page_count_per_classification = {}
        site.hierarchy_per_classification = {}
        site.flat_hierarchy_per_classification = {}
        site.hierarchy_lookup_per_classification = {}
        for taxonomy in taxonomies:
            site.page_count_per_classification[
                taxonomy.classification_name] = {}
            # Sort post lists
            for lang, posts_per_classification in site.posts_per_classification[
                    taxonomy.classification_name].items():
                # Ensure implicit classifications are inserted
                for classification in taxonomy.get_implicit_classifications(
                        lang):
                    if classification not in posts_per_classification:
                        posts_per_classification[classification] = []
                site.page_count_per_classification[
                    taxonomy.classification_name][lang] = {}
                # Convert sets to lists and sort them
                for classification in list(posts_per_classification.keys()):
                    posts = list(posts_per_classification[classification])
                    posts = self.site.sort_posts_chronologically(posts, lang)
                    taxonomy.sort_posts(posts, classification, lang)
                    posts_per_classification[classification] = posts
            # Create hierarchy information
            if taxonomy.has_hierarchy:
                site.hierarchy_per_classification[
                    taxonomy.classification_name] = {}
                site.flat_hierarchy_per_classification[
                    taxonomy.classification_name] = {}
                site.hierarchy_lookup_per_classification[
                    taxonomy.classification_name] = {}
                for lang, posts_per_classification in site.posts_per_classification[
                        taxonomy.classification_name].items():
                    # Compose hierarchy
                    hierarchy = {}
                    for classification in posts_per_classification.keys():
                        hier = taxonomy.extract_hierarchy(classification)
                        node = hierarchy
                        for he in hier:
                            if he not in node:
                                node[he] = {}
                            node = node[he]
                    hierarchy_lookup = {}

                    def create_hierarchy(hierarchy, parent=None, level=0):
                        """Create hierarchy."""
                        result = {}
                        for name, children in hierarchy.items():
                            node = hierarchy_utils.TreeNode(name, parent)
                            node.children = create_hierarchy(
                                children, node, level + 1)
                            node.classification_path = [
                                pn.name for pn in node.get_path()
                            ]
                            node.classification_name = taxonomy.recombine_classification_from_hierarchy(
                                node.classification_path)
                            hierarchy_lookup[node.classification_name] = node
                            result[node.name] = node
                        classifications = natsort.natsorted(result.keys(),
                                                            alg=natsort.ns.F
                                                            | natsort.ns.IC)
                        taxonomy.sort_classifications(classifications,
                                                      lang,
                                                      level=level)
                        return [
                            result[classification]
                            for classification in classifications
                        ]

                    root_list = create_hierarchy(hierarchy)
                    if '' in posts_per_classification:
                        node = hierarchy_utils.TreeNode('', parent=None)
                        node.children = root_list
                        node.classification_path = []
                        node.classification_name = ''
                        hierarchy_lookup[node.name] = node
                        root_list = [node]
                    flat_hierarchy = hierarchy_utils.flatten_tree_structure(
                        root_list)
                    # Store result
                    site.hierarchy_per_classification[
                        taxonomy.classification_name][lang] = root_list
                    site.flat_hierarchy_per_classification[
                        taxonomy.classification_name][lang] = flat_hierarchy
                    site.hierarchy_lookup_per_classification[
                        taxonomy.classification_name][lang] = hierarchy_lookup
                taxonomy.postprocess_posts_per_classification(
                    site.posts_per_classification[
                        taxonomy.classification_name],
                    site.flat_hierarchy_per_classification[
                        taxonomy.classification_name],
                    site.hierarchy_lookup_per_classification[
                        taxonomy.classification_name])
            else:
                taxonomy.postprocess_posts_per_classification(
                    site.posts_per_classification[
                        taxonomy.classification_name])

        # Check for valid paths and for collisions
        taxonomy_outputs = {
            lang: dict()
            for lang in site.config['TRANSLATIONS'].keys()
        }
        quit = False
        for taxonomy in taxonomies:
            # Check for collisions (per language)
            for lang in site.config['TRANSLATIONS'].keys():
                if not taxonomy.is_enabled(lang):
                    continue
                for classification, posts in site.posts_per_classification[
                        taxonomy.classification_name][lang].items():
                    # Do we actually generate this classification page?
                    filtered_posts = [
                        x for x in posts
                        if self.site.config["SHOW_UNTRANSLATED_POSTS"]
                        or x.is_translation_available(lang)
                    ]
                    generate_list = taxonomy.should_generate_classification_page(
                        classification, filtered_posts, lang)
                    if not generate_list:
                        continue
                    # Obtain path as tuple
                    path = site.path_handlers[taxonomy.classification_name](
                        classification, lang)
                    # Check that path is OK
                    for path_element in path:
                        if len(path_element) == 0:
                            utils.LOGGER.error(
                                "{0} {1} yields invalid path '{2}'!".format(
                                    taxonomy.classification_name.title(),
                                    classification, '/'.join(path)))
                            quit = True
                    # Combine path
                    path = os.path.join(
                        *[os.path.normpath(p) for p in path if p != '.'])
                    # Determine collisions
                    if path in taxonomy_outputs[lang]:
                        other_classification_name, other_classification, other_posts = taxonomy_outputs[
                            lang][path]
                        if other_classification_name == taxonomy.classification_name and other_classification == classification:
                            taxonomy_outputs[lang][path][2].extend(
                                filtered_posts)
                        else:
                            utils.LOGGER.error(
                                'You have classifications that are too similar: {0} "{1}" and {2} "{3}" both result in output path {4} for language {5}.'
                                .format(taxonomy.classification_name,
                                        classification,
                                        other_classification_name,
                                        other_classification, path, lang))
                            utils.LOGGER.error(
                                '{0} "{1}" is used in: {2}'.format(
                                    taxonomy.classification_name.title(),
                                    classification, ', '.join(
                                        sorted([
                                            p.source_path
                                            for p in filtered_posts
                                        ]))))
                            utils.LOGGER.error(
                                '{0} "{1}" is used in: {2}'.format(
                                    other_classification_name.title(),
                                    other_classification, ', '.join(
                                        sorted([
                                            p.source_path for p in other_posts
                                        ]))))
                            quit = True
                    else:
                        taxonomy_outputs[lang][path] = (
                            taxonomy.classification_name, classification,
                            list(posts))
        if quit:
            sys.exit(1)
        blinker.signal('taxonomies_classified').send(site)