pyformatjson 0.0.1__tar.gz → 0.0.3__tar.gz

{pyformatjson-0.0.1 → pyformatjson-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyformatjson
-Version: 0.0.1
+Version: 0.0.3
 Summary: pyformatjson
 License: GPL-3.0-or-later
 Keywords: Python,json

pyformatjson-0.0.3/pyformatjson/__init__.py

@@ -0,0 +1,17 @@
+"""PyFormatJSON: A Python library for formatting and processing JSON data for conferences and journals.
+
+This package provides utilities for processing conference and journal data from JSON files,
+generating markdown documentation, and creating various formatted outputs for academic
+publication management.
+
+Modules:
+    core: Core functionality for data processing and JSON manipulation
+    tools: Utility tools for data generation and markdown writing
+
+Classes:
+    GenerateDataDict: Generates data dictionaries from JSON input
+    WriteDataToMd: Writes publication data to Markdown files
+
+Functions:
+    main_generate_md_files: Main function to generate markdown files for conferences and journals
+"""

pyformatjson-0.0.3/pyformatjson/core/_base.py

@@ -0,0 +1,223 @@
+# coding=utf-8
+
+import os
+import re
+from typing import List
+
+
+def split_text_by_length(text, max_length=120) -> List[str]:
+    """Split text into lines of specified maximum length.
+
+    This function breaks long text into multiple lines, ensuring each line
+    does not exceed the specified maximum length. It attempts to break at
+    word boundaries when possible.
+
+    Args:
+        text (str): The input text to be split into lines.
+        max_length (int, optional): Maximum length for each line. Defaults to 120.
+
+    Returns:
+        List[str]: A list of text lines, each not exceeding max_length characters.
+
+    Example:
+        >>> split_text_by_length("This is a very long text that needs to be split", 20)
+        ['This is a very long', 'text that needs to be', 'split']
+    """
+    lines = []
+    while text:
+        if len(text) <= max_length:
+            lines.append(text)
+            break
+
+        split_pos = text.rfind(" ", 0, max_length + 1)
+        if split_pos == -1:
+            split_pos = max_length
+
+        line = text[:split_pos]
+        lines.append(line)
+
+        text = text[split_pos:]
+
+    new_lines = []
+    for line in lines:
+        new_lines.append(line)
+    return new_lines
+
+
+def split_data_list(split_pattern: str, data_list: List[str], last_next: str = "next") -> List[str]:
+    """Split data list according to the split pattern.
+
+    This function splits each string in the data list using the provided regex pattern
+    and reconstructs the data based on the last_next parameter. The pattern must use
+    capturing parentheses to define split points.
+
+    Args:
+        split_pattern (str): Regular expression pattern for splitting. Must use capturing
+            parentheses, e.g., r"(\n)" for newline splits.
+        data_list (List[str]): List of strings to be split and processed.
+        last_next (str, optional): Determines how to handle split parts. "next" places
+            the split character at the beginning of the next part, "last" places it at
+            the end of the current part. Defaults to "next".
+
+    Returns:
+        List[str]: New list of processed strings with empty strings filtered out.
+
+    Raises:
+        re.error: If the split_pattern is not a valid regular expression.
+
+    Example:
+        >>> split_data_list(r"(\n)", ["line1\nline2", "line3\nline4"], "next")
+        ['line1', 'line2', 'line3', 'line4']
+    """
+    new_data_list = []
+    for line in data_list:
+        split_list = re.split(split_pattern, line)
+        list_one = split_list[0 : len(split_list) : 2]
+        list_two = split_list[1 : len(split_list) : 2]
+
+        temp = []
+        if last_next == "next":
+            list_two.insert(0, "")
+            temp = [list_two[i] + list_one[i] for i in range(len(list_one))]
+        if last_next == "last":
+            list_two.append("")
+            temp = [list_one[i] + list_two[i] for i in range(len(list_one))]
+        new_data_list.extend(temp)
+    new_data_list = [line for line in new_data_list if line.strip()]
+    return new_data_list
+
+
+def standardize_path(path_input: str) -> str:
+    """Standardize and ensure a directory path exists.
+
+    This function expands environment variables and user home directory references
+    in the path, then creates the directory if it doesn't exist.
+
+    Args:
+        path_input (str): The input path to be standardized and created.
+
+    Returns:
+        str: The standardized absolute path.
+
+    Example:
+        >>> standardize_path("~/Documents/data")
+        '/Users/username/Documents/data'
+    """
+    path_input = os.path.expandvars(os.path.expanduser(path_input))
+    if not os.path.exists(path_input):
+        os.makedirs(path_input)
+    return path_input
+
+
+def sort_strings_with_embedded_numbers(s: str) -> List[str]:
+    """Split string into pieces for natural sorting with embedded numbers.
+
+    This function splits a string into pieces where numbers are converted to integers
+    for proper natural sorting (e.g., "item2" comes before "item10").
+
+    Args:
+        s (str): The string to be split into sortable pieces.
+
+    Returns:
+        List[str]: List of string pieces with numbers converted to integers.
+
+    Example:
+        >>> sort_strings_with_embedded_numbers("item10")
+        ['item', 10]
+    """
+    re_digits = re.compile(r"(\d+)")
+    pieces = re_digits.split(s)
+    pieces[1::2] = map(int, pieces[1::2])
+    return pieces
+
+
+def sort_int_str(str_int: List[str], reverse: bool = False) -> List[str]:
+    """Sort list of strings with embedded numbers naturally.
+
+    This function sorts a list of strings using natural sorting that handles
+    embedded numbers correctly (e.g., "item2" comes before "item10").
+
+    Args:
+        str_int (List[str]): List of strings to be sorted.
+        reverse (bool, optional): If True, sorts in descending order. Defaults to False.
+
+    Returns:
+        List[str]: Sorted list of strings.
+
+    Example:
+        >>> sort_int_str(["item10", "item2", "item1"])
+        ['item1', 'item2', 'item10']
+    """
+    return sorted(str_int, key=sort_strings_with_embedded_numbers, reverse=reverse)
+
+
+class IterateSortDict(object):
+    """A class for recursively sorting dictionary keys with natural sorting.
+
+    This class provides methods to sort dictionary keys recursively, handling
+    nested dictionaries and using natural sorting for strings with embedded numbers.
+
+    Attributes:
+        reverse (bool): If True, sorts keys in descending order. Defaults to False.
+
+    Example:
+        >>> sorter = IterateSortDict(reverse=False)
+        >>> data = {"item10": {"sub2": 1, "sub1": 2}, "item2": 3}
+        >>> sorted_data = sorter.dict_update(data)
+    """
+
+    def __init__(self, reverse: bool = False) -> None:
+        """Initialize the IterateSortDict instance.
+
+        Args:
+            reverse (bool, optional): If True, sorts keys in descending order.
+                Defaults to False.
+        """
+        self.reverse = reverse
+
+    def dict_update(self, old):
+        """Update and sort a dictionary recursively.
+
+        This method sorts the dictionary keys and recursively processes
+        any nested dictionaries.
+
+        Args:
+            old (dict): The dictionary to be sorted and updated.
+
+        Returns:
+            dict: The updated dictionary with sorted keys at all levels.
+        """
+        old = self.dict_sort_iteration(old)
+        old = self.dict_sort(old)
+        return old
+
+    def dict_sort_iteration(self, old: dict):
+        """Recursively sort nested dictionaries.
+
+        This method iterates through the dictionary and recursively sorts
+        any nested dictionary values.
+
+        Args:
+            old (dict): The dictionary to be processed recursively.
+
+        Returns:
+            dict: The dictionary with nested dictionaries sorted.
+        """
+        for key in old:
+            if isinstance(old[key], dict):
+                old[key] = self.dict_update(old[key])
+        return old
+
+    def dict_sort(self, old: dict):
+        """Sort dictionary keys using natural sorting.
+
+        This method sorts the top-level keys of the dictionary using
+        natural sorting that handles embedded numbers.
+
+        Args:
+            old (dict): The dictionary whose keys are to be sorted.
+
+        Returns:
+            dict: A new dictionary with sorted keys.
+        """
+        return {k: old[k] for k in sort_int_str(list(old.keys()), self.reverse)}

{pyformatjson-0.0.1 → pyformatjson-0.0.3}/pyformatjson/core/update_json.py

@@ -8,7 +8,24 @@ from ._base import split_data_list, split_text_by_length
 
 
 def load_json_data(path_json: str, filename: str) -> Dict:
-    """Load JSON data from file."""
+    """Load JSON data from a specified file.
+
+    This function attempts to load JSON data from a file located in the specified
+    directory. If the file doesn't exist or there's an error loading it, an empty
+    dictionary is returned.
+
+    Args:
+        path_json (str): Directory path containing the JSON file.
+        filename (str): Name of the JSON file (without .json extension).
+
+    Returns:
+        Dict: The loaded JSON data as a dictionary, or empty dict if file not found
+            or error occurs.
+
+    Example:
+        >>> load_json_data("/data", "conferences")
+        {"publisher1": {"conferences": {...}}}
+    """
     try:
         file_path = os.path.join(path_json, f"{filename}.json")
         if not os.path.exists(file_path):
@@ -23,15 +40,25 @@ def load_json_data(path_json: str, filename: str) -> Dict:
 
 
 def update_json_file(path_root: str, conferences_or_journals: str) -> Dict[str, Any]:
-    """
-    Update and format JSON file containing conference/journal data.
+    """Update and format JSON file containing conference/journal data.
+
+    This function loads JSON data, processes and formats text fields by splitting
+    long text into appropriate lengths, checks for duplicate abbreviations, and
+    saves the updated data back to the file.
 
     Args:
-        path_root (str): Root directory path
-        conferences_or_journals (str): Type of publication ('conferences' or 'journals')
+        path_root (str): Root directory path containing the JSON file.
+        conferences_or_journals (str): Type of publication ('conferences' or 'journals').
 
     Returns:
-        Dict[str, Any]: Processed JSON data
+        Dict[str, Any]: Processed JSON data dictionary.
+
+    Raises:
+        ValueError: If duplicate abbreviations are found in the data.
+
+    Example:
+        >>> update_json_file("/data", "conferences")
+        {"publisher1": {"conferences": {"conf1": {...}}}}
     """
     # Load Json Data
     json_dict = load_json_data(path_root, conferences_or_journals)
@@ -68,15 +95,21 @@ def update_json_file(path_root: str, conferences_or_journals: str) -> Dict[str,
 
 
 def _check_duplicate_abbr(json_dict: Dict[str, Any], conferences_or_journals: str) -> None:
-    """
-    Check for duplicate abbreviations in the data.
+    """Check for duplicate abbreviations in the data.
+
+    This function validates that there are no duplicate abbreviations within
+    the same publication type across all publishers.
 
     Args:
-        json_dict: JSON data dictionary
-        conferences_or_journals (str): Type of publication ('conferences' or 'journals')
+        json_dict (Dict[str, Any]): JSON data dictionary containing publication information.
+        conferences_or_journals (str): Type of publication ('conferences' or 'journals').
 
     Raises:
-        ValueError: If duplicate abbreviations are found
+        ValueError: If duplicate abbreviations are found in the data.
+
+    Example:
+        >>> _check_duplicate_abbr(data, "conferences")
+        # Raises ValueError if "ICML" appears twice in conferences
     """
     abbr_list = []
 

pyformatjson-0.0.3/pyformatjson/main.py

@@ -0,0 +1,155 @@
+# coding=utf-8
+
+import json
+import os
+from typing import Optional
+
+from .core._base import standardize_path
+from .core.update_json import load_json_data, update_json_file
+from .tools.generate_dict import GenerateDataDict
+from .tools.write_dict import WriteDataToMd
+
+
+def main_generate_md_files(
+    path_json: str,
+    path_output_md: str,
+    path_output_simplified_json: str,
+    path_spidered_bibs: Optional[str] = None,
+    for_vue: bool = True,
+    conferences_or_journals: Optional[str] = None,
+    keywords_category_name: str = "",
+) -> None:
+    """Generate markdown files for conferences and journals.
+
+    This function processes JSON data containing conference and journal information,
+    generates various markdown documentation files, and creates simplified JSON outputs.
+    It supports both conference and journal processing with customizable keyword categories.
+
+    Args:
+        path_json (str): Path to the input JSON data file containing publication information.
+        path_output_md (str): Output directory path where markdown files will be saved.
+        path_output_simplified_json (str): Output directory path for simplified JSON files.
+        path_spidered_bibs (Optional[str], optional): Directory containing crawled BibTeX files.
+            Defaults to None.
+        for_vue (bool, optional): Whether to generate Vue.js-compatible format for date calculations.
+            Defaults to True.
+        conferences_or_journals (Optional[str], optional): Specify 'conferences' or 'journals' to
+            process only one type, or None to process both. Defaults to None.
+        keywords_category_name (str, optional): The category name for keywords filtering.
+            Defaults to "".
+
+    Returns:
+        None: This function does not return a value.
+
+    Raises:
+        FileNotFoundError: If the input JSON file or required directories are not found.
+        ValueError: If there are issues with the data format or duplicate abbreviations.
+
+    Example:
+        >>> main_generate_md_files(
+        ...     path_json="/data/publications.json",
+        ...     path_output_md="/output/markdown",
+        ...     path_output_simplified_json="/output/json",
+        ...     for_vue=True,
+        ...     conferences_or_journals="conferences"
+        ... )
+    """
+    # Standardize all paths
+    path_json = standardize_path(path_json)
+    path_output_md = standardize_path(path_output_md)
+    path_output_simplified_json = standardize_path(path_output_simplified_json)
+
+    path_spidered_bibs = standardize_path(path_spidered_bibs) if path_spidered_bibs else ""
+
+    # Process keyword category name and load data
+    keywords_category_name = keywords_category_name.lower().strip() if keywords_category_name else ""
+    category_prefix = f"{keywords_category_name}_" if keywords_category_name else ""
+    keywords_list = load_json_data(path_json, "keywords").get(f"{category_prefix}keywords", [])
+
+    # Validate data availability
+    if not keywords_list or not keywords_category_name:
+        keywords_list, keywords_category_name = [], ""
+
+    # Process both conferences and journals
+    for cj, ia in zip(["conferences", "journals"], ["inproceedings", "article"]):
+        # Skip if specific type requested and doesn't match
+        if conferences_or_journals and conferences_or_journals.lower() != cj:
+            continue
+
+        # Update JSON data
+        json_dict = update_json_file(path_json, cj)
+        if not json_dict:
+            continue
+
+        # Simplify JSON data
+        simplify_json(json_dict, cj, path_output_simplified_json)
+
+        # Generate data dictionaries
+        path_spidered_cj = os.path.join(path_spidered_bibs, cj.title())
+        generater = GenerateDataDict(cj, ia, json_dict, for_vue, path_spidered_cj)
+        publisher_meta_dict, publisher_abbr_meta_dict, keyword_abbr_meta_dict = generater.generate()
+        if not (publisher_meta_dict and publisher_abbr_meta_dict and keyword_abbr_meta_dict):
+            continue
+
+        # Initialize writer and save all markdown files
+        _path_output = os.path.join(path_output_md, f"{cj.title()}")
+        save_data = WriteDataToMd(
+            cj, ia, publisher_meta_dict, publisher_abbr_meta_dict, keyword_abbr_meta_dict, _path_output
+        )
+        # Save various documentation files
+        save_data.save_introductions()
+        save_data.save_categories(keywords_category_name, keywords_list)
+        save_data.save_categories_separate_keywords()
+
+        save_data.save_publishers()
+        save_data.save_publishers_separate_abbrs()
+
+        save_data.save_statistics(keywords_category_name, keywords_list)
+        save_data.save_statistics_separate_abbrs()
+
+    return None
+
+
+def simplify_json(json_dict, cj: str, output_dir: str) -> None:
+    """Simplify JSON dictionary by extracting only essential fields.
+
+    This function creates a simplified version of the JSON dictionary containing
+    only the names_abbr and names_full fields for each publisher and publication type.
+    The simplified data is saved to a new JSON file in the specified output directory.
+
+    Args:
+        json_dict (dict): The original JSON dictionary containing publication data.
+        cj (str): The type of publication, either 'conferences' or 'journals'.
+        output_dir (str): Directory path where the simplified JSON file will be saved.
+
+    Returns:
+        None: This function does not return a value.
+
+    Note:
+        The function creates a new JSON file named '{cj}.json' in the output directory.
+        Only the 'names_abbr' and 'names_full' fields are preserved in the simplified version.
+
+    Example:
+        >>> simplify_json(
+        ...     json_dict=publication_data,
+        ...     cj="conferences",
+        ...     output_dir="/output/simplified"
+        ... )
+    """
+    new_json_dict = {}
+    for publisher in json_dict:
+        for abbr in json_dict[publisher][cj.lower()]:
+            names_abbr = json_dict[publisher][cj.lower()][abbr].get("names_abbr", [])
+            names_full = json_dict[publisher][cj.lower()][abbr].get("names_full", [])
+
+            new_json_dict.setdefault(publisher, {}).setdefault(cj.lower(), {}).setdefault(abbr, {}).update(
+                {"names_abbr": names_abbr, "names_full": names_full}
+            )
+
+    # Save updated JSON
+    if new_json_dict:
+        path_file = os.path.join(output_dir, f"{cj}.json")
+        with open(path_file, "w", encoding="utf-8") as f:
+            f.write(json.dumps(new_json_dict, indent=4, sort_keys=True, ensure_ascii=True))
+
+    return None

{pyformatjson-0.0.1 → pyformatjson-0.0.3}/pyformatjson/tools/generate_dict.py

@@ -7,6 +7,21 @@ from typing import Optional
 
 
 def conference_journal_header():
+    """Generate markdown table headers for conferences and journals.
+
+    This function creates the appropriate markdown table headers for displaying
+    conference and journal information in tabular format.
+
+    Returns:
+        tuple: A tuple containing two lists:
+            - conference_header: Markdown table headers for conferences
+            - journal_header: Markdown table headers for journals
+
+    Example:
+        >>> conf_header, journal_header = conference_journal_header()
+        >>> print(conf_header[0])
+        |Publishers|Full/Homepage|Abbr/About|Acronym/Archive|Period/DBLP|...
+    """
     o = "|Publishers|Full/Homepage|Abbr/About|"
     t = "|-         |-            |-         |"
     conference_header = [
@@ -21,6 +36,29 @@ def conference_journal_header():
 
 
 class GenerateDataDict(object):
+    """Generate data dictionaries from JSON input for conferences and journals.
+
+    This class processes JSON data containing conference or journal information
+    and generates structured dictionaries for markdown table generation, including
+    publisher metadata, keyword-based indexing, and Mermaid diagram data.
+
+    Attributes:
+        cj (str): Type of publication ('conferences' or 'journals').
+        ia (str): Publication type ('inproceedings' or 'article').
+        json_dict (dict): Input JSON data containing publication information.
+        path_spidered_cj (Optional[str]): Path to spidered conference/journal data.
+        for_vue (bool): Whether to generate Vue.js-compatible format.
+
+    Example:
+        >>> generator = GenerateDataDict(
+        ...     conferences_or_journals="conferences",
+        ...     inproceedings_or_article="inproceedings",
+        ...     json_dict=publication_data,
+        ...     for_vue=True
+        ... )
+        >>> publisher_meta, publisher_abbr, keyword_abbr = generator.generate()
+    """
+
     def __init__(
         self,
         conferences_or_journals: str,
@@ -29,6 +67,17 @@ class GenerateDataDict(object):
         for_vue: bool = True,
         path_spidered_conferences_or_journals: Optional[str] = None,
     ) -> None:
+        """Initialize the GenerateDataDict instance.
+
+        Args:
+            conferences_or_journals (str): Type of publication ('conferences' or 'journals').
+            inproceedings_or_article (str): Publication type ('inproceedings' or 'article').
+            json_dict (dict): Input JSON data containing publication information.
+            for_vue (bool, optional): Whether to generate Vue.js-compatible format.
+                Defaults to True.
+            path_spidered_conferences_or_journals (Optional[str], optional): Path to
+                spidered conference/journal data. Defaults to None.
+        """
         self.cj = conferences_or_journals
         self.ia = inproceedings_or_article
         self.json_dict = json_dict
@@ -37,13 +86,22 @@ class GenerateDataDict(object):
         self.for_vue = for_vue
 
     def generate(self):
-        """
-        Generate publisher metadata and keyword-based publication information.
+        """Generate publisher metadata and keyword-based publication information.
+
+        This method processes the JSON data to create three main dictionaries:
+        1. Publisher metadata with URLs and descriptions
+        2. Publisher abbreviation metadata with detailed publication info
+        3. Keyword-based metadata for easy searching and categorization
 
         Returns:
-            tuple: Contains two dictionaries:
-                - publisher_meta_abbr_dict: Publisher metadata and abbreviations
-                - publication_keyword_row_info_dict: Keyword-indexed publication info
+            tuple: A tuple containing three dictionaries:
+                - publisher_meta_dict: Publisher metadata including URLs and descriptions
+                - publisher_abbr_meta_dict: Publication details indexed by publisher and abbreviation
+                - keyword_abbr_meta_dict: Publication details indexed by keywords
+
+        Example:
+            >>> generator = GenerateDataDict(...)
+            >>> pub_meta, pub_abbr, keyword_abbr = generator.generate()
         """
         publisher_meta_dict, keyword_abbr_meta_dict, publisher_abbr_meta_dict = {}, {}, {}
 
@@ -76,13 +134,15 @@ class GenerateDataDict(object):
             remarks = [p for p in self.json_dict[publisher].get("txt_remarks", []) if p.strip()]
 
             # Update publisher metadata
-            publisher_meta_dict.setdefault(publisher, {}).update({
-                "full_name_url": full_url,
-                "txt_abouts": abouts,
-                "txt_remarks": remarks,
-                "urls_about": urls_about,
-                "url_conferences_or_journals": f"[{self.cj.title()}]({urls_cj[0]})" if urls_cj else "",
-            })
+            publisher_meta_dict.setdefault(publisher, {}).update(
+                {
+                    "full_name_url": full_url,
+                    "txt_abouts": abouts,
+                    "txt_remarks": remarks,
+                    "urls_about": urls_about,
+                    "url_conferences_or_journals": f"[{self.cj.title()}]({urls_cj[0]})" if urls_cj else "",
+                }
+            )
 
             # Process each abbreviation (conference/journal)
             for abbr in self.json_dict[publisher][self.cj]:
@@ -105,17 +165,31 @@ class GenerateDataDict(object):
         return publisher_meta_dict, publisher_abbr_meta_dict, keyword_abbr_meta_dict
 
     def conference_or_journal(self, publisher_url: str, abbr: str, abbr_dict: dict):
-        """
-        Process conference or journal data and generate formatted information.
+        """Process conference or journal data and generate formatted information.
+
+        This method processes individual conference or journal data, validates
+        name lengths, extracts information, formats URLs, and generates table
+        row data for markdown output.
 
         Args:
-            publisher_url: Publisher's URL
-            abbr: Abbreviation identifier
-            abbr_dict: Dictionary containing publication details
+            publisher_url (str): Publisher's URL for markdown linking.
+            abbr (str): Abbreviation identifier for the publication.
+            abbr_dict (dict): Dictionary containing publication details including
+                names, URLs, dates, scores, and keywords.
 
         Returns:
-            dict: Contains formatted about text, remarks, and table row
-            list: Sorted list of keywords
+            tuple: A tuple containing:
+                - dict: Contains formatted about text, remarks, and table row data
+                - list: Sorted list of keywords for the publication
+
+        Raises:
+            ValueError: If full and abbreviated names have mismatched lengths.
+
+        Example:
+            >>> result = generator.conference_or_journal(
+            ...     "https://publisher.com", "ICML", conf_data
+            ... )
+            >>> abouts, keywords = result
         """
         # Validate full and abbreviated names match in length
         self._validate_name_lengths(abbr_dict)
@@ -138,23 +212,42 @@ class GenerateDataDict(object):
 
         # Generate appropriate table row based on type
         row_inf = self._generate_table_row(
-            publisher_url, full_name, abbr_name, url_home,
-            url_about, period, top, keywords_url, abbr, abbr_dict
+            publisher_url, full_name, abbr_name, url_home, url_about, period, top, keywords_url, abbr, abbr_dict
         )
 
         return {"txt_abouts": abouts, "txt_remarks": remarks, "row_inf": row_inf}, keywords
 
     def _validate_name_lengths(self, abbr_dict: dict):
-        """Validate that full and abbreviated names arrays have equal length."""
+        """Validate that full and abbreviated names arrays have equal length.
+
+        This method ensures that the full names and abbreviated names arrays
+        have the same length, which is required for proper data processing.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+
+        Raises:
+            ValueError: If the lengths of names_full and names_abbr don't match.
+        """
         full_names = abbr_dict.get("names_full", [])
         abbr_names = abbr_dict.get("names_abbr", [])
         if len(full_names) != len(abbr_names):
-            raise ValueError(f"Length mismatch: {len(full_names)} full names vs {len(abbr_names)} abbreviated names")
+            raise ValueError(f"Length mismatch: {len(full_names)} {full_names} vs {len(abbr_names)} abbreviated names")
 
     def _extract_full_abbr_names(self, abbr_dict: dict):
-        """Extract full and abbreviated names from dictionary."""
+        """Extract full and abbreviated names from dictionary.
+
+        This method extracts the appropriate full and abbreviated names based on
+        the publication type (conferences vs journals).
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+
+        Returns:
+            tuple: A tuple containing (full_name, abbr_name).
+        """
         # For journals: use first full name from list; for conferences: use single name
-        full_name = (abbr_dict.get("names_full", [""])[0] if self.cj == "journals" else abbr_dict.get("name", ""))
+        full_name = abbr_dict.get("names_full", [""])[0] if self.cj == "journals" else abbr_dict.get("name", "")
         abbr_name = abbr_dict.get("names_abbr", [""])[0]
         return full_name, abbr_name
 
@@ -175,7 +268,7 @@ class GenerateDataDict(object):
         if acronym_dblp := abbr_dict.get("acronym_dblp", ""):
             journal_conf = "journals" if self.cj == "journals" else "conf"
             dblp_url = f"https://dblp.org/db/{journal_conf}/{acronym_dblp}/index.html"
-            period = f'[{period}]({dblp_url})'
+            period = f"[{period}]({dblp_url})"
 
         return period
 
@@ -209,9 +302,7 @@ class GenerateDataDict(object):
         all_keywords = sorted(set(all_keywords))
         # Create Google search links for each keyword
         google_base = "https://www.google.com/search?q="
-        keywords_url = [
-            f"[{keyword}]({google_base}" + re.sub(r"\s+", "+", keyword) + ")" for keyword in all_keywords
-        ]
+        keywords_url = [f"[{keyword}]({google_base}" + re.sub(r"\s+", "+", keyword) + ")" for keyword in all_keywords]
 
         # For category
         # Flatten keywords and remove duplicates
@@ -276,19 +367,28 @@ class GenerateDataDict(object):
         abstract_due, start_date, today = self._process_conference_dates(abbr_dict)
 
         # Format date indicators for Vue or standard display
-        abstract_indicator, start_indicator = self._format_date_indicators(
-            abstract_due, start_date, today
-        )
+        abstract_indicator, start_indicator = self._format_date_indicators(abstract_due, start_date, today)
 
         # Get year URL for start date link
         year_url = abbr_dict.get("conf_url", "")
 
         # Build and return markdown table row
         return self._build_conference_row(
-            publisher_url, full_name, abbr_name, url_home, url_about,
-            archive_display, period, top, abbr_dict, abstract_due,
-            abstract_indicator, start_date, start_indicator, year_url,
-            keywords
+            publisher_url,
+            full_name,
+            abbr_name,
+            url_home,
+            url_about,
+            archive_display,
+            period,
+            top,
+            abbr_dict,
+            abstract_due,
+            abstract_indicator,
+            start_date,
+            start_indicator,
+            year_url,
+            keywords,
         )
 
     def _process_conference_dates(self, abbr_dict):
@@ -328,8 +428,22 @@ class GenerateDataDict(object):
         return abstract_indicator, start_indicator
 
     def _build_conference_row(
-        self, publisher_url, full_name, abbr_name, url_home, url_about, archive_display, period, top, abbr_dict,
-        abstract_due, abstract_indicator, start_date, start_indicator, year_url, keywords
+        self,
+        publisher_url,
+        full_name,
+        abbr_name,
+        url_home,
+        url_about,
+        archive_display,
+        period,
+        top,
+        abbr_dict,
+        abstract_due,
+        abstract_indicator,
+        start_date,
+        start_indicator,
+        year_url,
+        keywords,
     ):
         """Construct conference table row string."""
         # Format date strings
@@ -340,19 +454,21 @@ class GenerateDataDict(object):
         start_date_display = self._format_link(start_date_str, year_url) if start_date_str else ""
 
         # Build table row
-        return f"|{publisher_url}|" \
-               f"{self._format_link(full_name, url_home)}|" \
-               f"{self._format_link(abbr_name, url_about)}|" \
-               f"{archive_display}|" \
-               f"{period}|" \
-               f"{top}|" \
-               f"{abbr_dict.get('score_ccf', '')}|" \
-               f"{abstract_date_str}|" \
-               f"{abstract_indicator}|" \
-               f"{start_date_display}|" \
-               f"{start_indicator}|" \
-               f"{abbr_dict.get('conf_location', '').strip()}|" \
-               f"{'; '.join(keywords)}|"
+        return (
+            f"|{publisher_url}|"
+            f"{self._format_link(full_name, url_home)}|"
+            f"{self._format_link(abbr_name, url_about)}|"
+            f"{archive_display}|"
+            f"{period}|"
+            f"{top}|"
+            f"{abbr_dict.get('score_ccf', '')}|"
+            f"{abstract_date_str}|"
+            f"{abstract_indicator}|"
+            f"{start_date_display}|"
+            f"{start_indicator}|"
+            f"{abbr_dict.get('conf_location', '').strip()}|"
+            f"{'; '.join(keywords)}|"
+        )
 
     # Journals
     def _generate_for_journal(
@@ -382,25 +498,26 @@ class GenerateDataDict(object):
 
         # Build and return markdown table row
         return self._build_journal_row(
-            publisher_url, full_name, abbr_name, url_home, url_about,
-            issues_display, period, top, abbr_dict, keywords
+            publisher_url, full_name, abbr_name, url_home, url_about, issues_display, period, top, abbr_dict, keywords
         )
 
     def _build_journal_row(
         self, publisher_url, full_name, abbr_name, url_home, url_about, issues_display, period, top, abbr_dict, keywords
     ):
         """Construct journal table row string."""
-        return f"|{publisher_url}|" \
-               f"{self._format_link(full_name, url_home)}|" \
-               f"{self._format_link(abbr_name, url_about)}|" \
-               f"{issues_display}|" \
-               f"{period}|" \
-               f"{top}|" \
-               f"{abbr_dict.get('score_ccf', '')}|" \
-               f"{abbr_dict.get('score_cas', '')}|" \
-               f"{abbr_dict.get('score_jcr', '')}|" \
-               f"{abbr_dict.get('score_if', '')}|" \
-               f"{'; '.join(keywords)}|"
+        return (
+            f"|{publisher_url}|"
+            f"{self._format_link(full_name, url_home)}|"
+            f"{self._format_link(abbr_name, url_about)}|"
+            f"{issues_display}|"
+            f"{period}|"
+            f"{top}|"
+            f"{abbr_dict.get('score_ccf', '')}|"
+            f"{abbr_dict.get('score_cas', '')}|"
+            f"{abbr_dict.get('score_jcr', '')}|"
+            f"{abbr_dict.get('score_if', '')}|"
+            f"{'; '.join(keywords)}|"
+        )
 
     # Mermaid data
     def generate_mermaid_data(self, publisher: str, abbr: str, inproceedings_or_article: str):
@@ -413,7 +530,7 @@ class GenerateDataDict(object):
         mermaid, data_dict = [], {}
         # |AAAI|1980|95|Proceedings of the First National Conference on Artificial Intelligence|
         regex = re.compile(r"\|.*\|([0-9]+)\|([0-9]+)\|.*\|")
-        with open(full_readme, "r") as file:
+        with open(full_readme, "r", encoding="utf-8") as file:
             data_list = file.readlines()
         for line in data_list:
             if mch := regex.search(line):
@@ -425,15 +542,15 @@ class GenerateDataDict(object):
             mermaid = ["```mermaid\n"]
             mermaid.extend(
                 [
-                    '---\n',
-                    'config:\n',
-                    '    xyChart:\n',
-                    '        width: 1200\n',
-                    '        height: 600\n',
-                    '    themeVariables:\n',
-                    '        xyChart:\n',
+                    "---\n",
+                    "config:\n",
+                    "    xyChart:\n",
+                    "        width: 1200\n",
+                    "        height: 600\n",
+                    "    themeVariables:\n",
+                    "        xyChart:\n",
                     '            titleColor: "#ff0000"\n',
-                    '---\n'
+                    "---\n",
                 ]
             )
             mermaid.extend(["xychart-beta\n", f'    title "{abbr}"\n'])

{pyformatjson-0.0.1 → pyformatjson-0.0.3}/pyformatjson/tools/write_dict.py

@@ -8,16 +8,55 @@ from .generate_dict import conference_journal_header
 
 
 def conference_journal_informations():
+    """Generate informational content for conferences and journals.
+
+    This function provides additional informational content that can be
+    included in markdown documentation for conferences and journals.
+
+    Returns:
+        tuple: A tuple containing two lists:
+            - conference_inf: List of informational strings for conferences
+            - journal_inf: List of informational strings for journals
+
+    Example:
+        >>> conf_info, journal_info = conference_journal_informations()
+        >>> print(conf_info[0])
+        !> [List of Upcoming International Conferences](...)
+    """
     conference_inf = [
         "!> [List of Upcoming International Conferences](https://internationalconferencealerts.com/all-events.php)\n\n",
-        "!> [Conferences in Theoretical Computer Science](https://www.lix.polytechnique.fr/~hermann/conf.php)\n\n"
+        "!> [Conferences in Theoretical Computer Science](https://www.lix.polytechnique.fr/~hermann/conf.php)\n\n",
     ]
     journal_inf = []
     return conference_inf, journal_inf
 
 
 class WriteDataToMd(object):
-    """Class to write publication data to Markdown files."""
+    """Class to write publication data to Markdown files.
+
+    This class provides methods to generate various markdown documentation files
+    from processed publication data, including introduction files, categorized
+    listings, publisher information, and statistics.
+
+    Attributes:
+        cj (str): Type of publication ('conferences' or 'journals').
+        ia (str): Publication type ('inproceedings' or 'article').
+        publisher_meta_dict (dict): Publisher metadata dictionary.
+        publisher_abbr_meta_dict (dict): Publisher abbreviation metadata dictionary.
+        keyword_abbr_meta_dict (dict): Keyword-based metadata dictionary.
+        path_output (str): Output directory path for generated files.
+
+    Example:
+        >>> writer = WriteDataToMd(
+        ...     conferences_or_journals="conferences",
+        ...     inproceedings_or_article="inproceedings",
+        ...     publisher_meta_dict=pub_meta,
+        ...     publisher_abbr_meta_dict=pub_abbr,
+        ...     keyword_abbr_meta_dict=keyword_abbr,
+        ...     path_output="/output"
+        ... )
+        >>> writer.save_introductions()
+    """
 
     def __init__(
         self,
@@ -28,7 +67,16 @@ class WriteDataToMd(object):
         keyword_abbr_meta_dict: dict,
         path_output: str,
     ) -> None:
-        """Initialize with publication data and output path."""
+        """Initialize with publication data and output path.
+
+        Args:
+            conferences_or_journals (str): Type of publication ('conferences' or 'journals').
+            inproceedings_or_article (str): Publication type ('inproceedings' or 'article').
+            publisher_meta_dict (dict): Publisher metadata dictionary.
+            publisher_abbr_meta_dict (dict): Publisher abbreviation metadata dictionary.
+            keyword_abbr_meta_dict (dict): Keyword-based metadata dictionary.
+            path_output (str): Output directory path for generated files.
+        """
         self.cj = conferences_or_journals  # "conferences" or "journals"
         self.ia = inproceedings_or_article  # "inproceedings" or "article"
         self.publisher_meta_dict = publisher_meta_dict
@@ -41,7 +89,18 @@ class WriteDataToMd(object):
         ]
 
     def save_introductions(self) -> None:
-        """Save introduction file with all conferences/journals list."""
+        """Save introduction file with all conferences/journals list.
+
+        This method generates a comprehensive markdown file containing all
+        conferences or journals in a tabular format with appropriate headers
+        and informational content.
+
+        Returns:
+            None: This method does not return a value.
+
+        Note:
+            The output file is saved as 'Introductions_{type}.md' in the output directory.
+        """
         conference_header, journal_header = conference_journal_header()
         conference_inf, journal_inf = conference_journal_informations()
 
@@ -62,13 +121,13 @@ class WriteDataToMd(object):
         idx = 1
         for publisher in self.publisher_abbr_meta_dict:
             for abbr in self.publisher_abbr_meta_dict[publisher]:
-                row_info = self.publisher_abbr_meta_dict[publisher][abbr]['row_inf']
+                row_info = self.publisher_abbr_meta_dict[publisher][abbr]["row_inf"]
                 data_list.append(f"|{idx}{row_info}\n")
                 idx += 1
 
         # Write to file
         output_file = os.path.join(self.path_output, f"Introductions_{self.cj.title()}.md")
-        with open(output_file, "w") as f:
+        with open(output_file, "w", encoding="utf-8") as f:
             f.writelines(data_list)
 
     # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
@@ -88,7 +147,21 @@ class WriteDataToMd(object):
 
     # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
     def save_categories(self, keywords_category_name: str, keywords_list: List[str]) -> None:
-        """Save publications categorized by keywords."""
+        """Save publications categorized by keywords.
+
+        This method generates markdown files organizing publications by their
+        keywords, creating separate sections for each keyword category.
+
+        Args:
+            keywords_category_name (str): The category name for keywords filtering.
+            keywords_list (List[str]): List of keywords to include in the output.
+
+        Returns:
+            None: This method does not return a value.
+
+        Note:
+            The output file is saved as 'Categories_{type}_{category}.md' in the output directory.
+        """
         conference_header, journal_header = conference_journal_header()
         data_list = [f"# {self.cj.title()}\n\n"]
         data_list.extend(self._default_inf)
@@ -110,7 +183,9 @@ class WriteDataToMd(object):
 
         # Write to file
         category_postfix = f"_{keywords_category_name.title()}" if keywords_category_name else ""
-        with open(os.path.join(self.path_output, f"Categories_{self.cj.title()}{category_postfix}.md"), "w") as f:
+        with open(
+            os.path.join(self.path_output, f"Categories_{self.cj.title()}{category_postfix}.md"), "w", encoding="utf-8"
+        ) as f:
             f.writelines(data_list)
 
         return None
@@ -136,18 +211,31 @@ class WriteDataToMd(object):
 
             # Write keyword-specific file
             path_key = standardize_path(os.path.join(self.path_output, f"Categories_{self.cj.title()}"))
-            with open(os.path.join(path_key, f"{keyword.replace(' ', '_')}.md"), "w") as f:
+            # Create safe filename by replacing invalid characters
+            safe_keyword = "".join(c if c.isalnum() or c in "-_" else "_" for c in keyword)
+            with open(os.path.join(path_key, f"{safe_keyword}.md"), "w", encoding="utf-8") as f:
                 f.writelines(data_list)
 
         return None
 
     # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
     def save_publishers(self) -> None:
-        """Save publisher overview file with basic information."""
+        """Save publisher overview file with basic information.
+
+        This method generates a markdown file containing an overview of all
+        publishers with their basic information, about pages, and links to
+        detailed publisher-specific files.
+
+        Returns:
+            None: This method does not return a value.
+
+        Note:
+            The output file is saved as 'Publishers_{type}.md' in the output directory.
+        """
         data_list_pub = [
             f"# Introductions of Publishers and {self.cj.title()}\n\n",
             "| |Publishers|About US|Conferences/Journals|Separate Links|\n",
-            "|-|-         |-       |-                   |-             |\n"
+            "|-|-         |-       |-                   |-             |\n",
         ]
         idx = 1
 
@@ -171,7 +259,7 @@ class WriteDataToMd(object):
             idx += 1
 
         # Write to file
-        with open(os.path.join(self.path_output, f"Publishers_{self.cj.title()}.md"), "w") as f:
+        with open(os.path.join(self.path_output, f"Publishers_{self.cj.title()}.md"), "w", encoding="utf-8") as f:
             f.writelines(data_list_pub)
         return None
 
@@ -205,7 +293,7 @@ class WriteDataToMd(object):
 
                 # Add row information
                 row_info = self.publisher_abbr_meta_dict[pub][abbr]["row_inf"]
-                data_list.append(f'{row_info}\n\n')
+                data_list.append(f"{row_info}\n\n")
 
                 # Add remarks and about for this abbreviation
                 for flag in ["txt_remarks", "txt_abouts"]:
@@ -222,7 +310,7 @@ class WriteDataToMd(object):
 
             # Write publisher-specific file
             path_pub = standardize_path(os.path.join(self.path_output, f"Publishers_{self.cj.title()}"))
-            with open(os.path.join(path_pub, f"{pub}.md"), "w") as f:
+            with open(os.path.join(path_pub, f"{pub}.md"), "w", encoding="utf-8") as f:
                 f.writelines(data_list)
 
         return None
@@ -232,13 +320,15 @@ class WriteDataToMd(object):
         data_list = [
             f"# Statistics of keywords in {self.cj.title()}\n\n",
             "| |keywords|Separate Links|\n",
-            "|-|-      |-             |\n"
+            "|-|-      |-             |\n",
         ]
         idx = 1
 
         # Add publications for each category
         for keyword in self._default_or_customized_keywords(keywords_category_name, keywords_list):
-            local_url = f"[Link](data/{self.cj.title()}/Statistics_{self.cj.title()}/{keyword.replace(' ', '_')}.md)"
+            # Create safe filename for URL
+            safe_keyword = "".join(c if c.isalnum() or c in "-_" else "_" for c in keyword)
+            local_url = f"[Link](data/{self.cj.title()}/Statistics_{self.cj.title()}/{safe_keyword}.md)"
 
             # Create table row
             row = f"| {idx} | {keyword} | {local_url} |\n"
@@ -247,7 +337,9 @@ class WriteDataToMd(object):
 
         # Write to file
         category_postfix = f"_{keywords_category_name.title()}" if keywords_category_name else ""
-        with open(os.path.join(self.path_output, f"Statistics_{self.cj.title()}{category_postfix}.md"), "w") as f:
+        with open(
+            os.path.join(self.path_output, f"Statistics_{self.cj.title()}{category_postfix}.md"), "w", encoding="utf-8"
+        ) as f:
             f.writelines(data_list)
         return None
 
@@ -269,7 +361,7 @@ class WriteDataToMd(object):
 
                 # Add row information
                 row_info = self.keyword_abbr_meta_dict[keyword][abbr]["row_inf"]
-                data_list.append(f'{row_info}\n\n')
+                data_list.append(f"{row_info}\n\n")
 
                 # Add statistics if available
                 if statistics := self.keyword_abbr_meta_dict[keyword][abbr].get("statistics", []):
@@ -278,7 +370,9 @@ class WriteDataToMd(object):
 
             # Write publisher-specific file
             path_pub = standardize_path(os.path.join(self.path_output, f"Statistics_{self.cj.title()}"))
-            with open(os.path.join(path_pub, f"{keyword.replace(' ', '_')}.md"), "w") as f:
+            # Create safe filename by replacing invalid characters
+            safe_keyword = "".join(c if c.isalnum() or c in "-_" else "_" for c in keyword)
+            with open(os.path.join(path_pub, f"{safe_keyword}.md"), "w", encoding="utf-8") as f:
                 f.writelines(data_list)
 
         return None

{pyformatjson-0.0.1 → pyformatjson-0.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyformatjson"
-version = "0.0.1"
+version = "0.0.3"
 description = "pyformatjson"
 license = "GPL-3.0-or-later"
 authors = ["NextAI <nextartifintell@gmail.com>"]

pyformatjson-0.0.1/pyformatjson/core/_base.py

@@ -1,103 +0,0 @@
-# coding=utf-8
-
-import os
-import re
-from typing import List
-
-
-def split_text_by_length(text, max_length=120) -> List[str]:
-    lines = []
-    while text:
-        if len(text) <= max_length:
-            lines.append(text)
-            break
-
-        split_pos = text.rfind(" ", 0, max_length + 1)
-        if split_pos == -1:
-            split_pos = max_length
-
-        line = text[:split_pos]
-        lines.append(line)
-
-        text = text[split_pos:]
-
-    new_lines = []
-    for line in lines:
-        new_lines.append(line)
-    return new_lines
-
-
-def split_data_list(
-    split_pattern: str, data_list: List[str], last_next: str = "next"
-) -> List[str]:
-    r"""Split data list according to the split pattern.
-
-    The capturing parentheses must be used in the pattern, such as `(\n)`.
-
-    Args:
-        split_pattern (str): split pattern.
-        data_list (List[str]): data list.
-        last_next (str): "next" or "last".
-
-    Returns:
-        List[str]: new data list.
-
-    Examples:
-        split_pattern = r"(\n)", last_next = "next" or "last".
-    """
-    new_data_list = []
-    for line in data_list:
-        split_list = re.split(split_pattern, line)
-        list_one = split_list[0: len(split_list): 2]
-        list_two = split_list[1: len(split_list): 2]
-
-        temp = []
-        if last_next == "next":
-            list_two.insert(0, "")
-            temp = [list_two[i] + list_one[i] for i in range(len(list_one))]
-        if last_next == "last":
-            list_two.append("")
-            temp = [list_one[i] + list_two[i] for i in range(len(list_one))]
-        new_data_list.extend(temp)
-    new_data_list = [line for line in new_data_list if line.strip()]
-    return new_data_list
-
-
-def standardize_path(path_input: str) -> str:
-    path_input = os.path.expandvars(os.path.expanduser(path_input))
-    if not os.path.exists(path_input):
-        os.makedirs(path_input)
-    return path_input
-
-
-def sort_strings_with_embedded_numbers(s: str) -> List[str]:
-    re_digits = re.compile(r"(\d+)")
-    pieces = re_digits.split(s)
-    pieces[1::2] = map(int, pieces[1::2])
-    return pieces
-
-
-def sort_int_str(str_int: List[str], reverse: bool = False) -> List[str]:
-    return sorted(str_int, key=sort_strings_with_embedded_numbers, reverse=reverse)
-
-
-class IterateSortDict(object):
-    def __init__(self, reverse: bool = False) -> None:
-        self.reverse = reverse
-
-    def dict_update(self, old):
-        """Update."""
-        old = self.dict_sort_iteration(old)
-        old = self.dict_sort(old)
-        return old
-
-    def dict_sort_iteration(self, old: dict):
-        """Sort."""
-        for key in old:
-            if isinstance(old[key], dict):
-                old[key] = self.dict_update(old[key])
-        return old
-
-    def dict_sort(self, old: dict):
-        """Sort."""
-        return {k: old[k] for k in sort_int_str(list(old.keys()), self.reverse)}

pyformatjson-0.0.1/pyformatjson/main.py

@@ -1,79 +0,0 @@
-# coding=utf-8
-
-import os
-from typing import Optional
-
-from .core._base import standardize_path
-from .core.update_json import load_json_data, update_json_file
-from .tools.generate_dict import GenerateDataDict
-from .tools.write_dict import WriteDataToMd
-
-
-def main_generate_md_files(
-    path_json: str,
-    path_output: str,
-    path_spidered_bibs: Optional[str] = None,
-    for_vue: bool = True,
-    conferences_or_journals: Optional[str] = None,
-    keywords_category_name: str = ""
-) -> None:
-    """
-    Generate markdown files for conferences and journals.
-
-    Args:
-        path_json: Path to JSON data file
-        path_output: Output directory for markdown files
-        path_spidered_bibs: Directory containing crawled BibTeX files
-        for_vue: Whether to generate Vue-compatible format
-        conferences_or_journals: Specify 'conferences' or 'journals', None for both
-        keywords_category_name: The category name of keywords
-    """
-    # Standardize all paths
-    path_json = standardize_path(path_json)
-    path_output = standardize_path(path_output)
-    path_spidered_bibs = standardize_path(path_spidered_bibs) if path_spidered_bibs else ""
-
-    # Process keyword category name and load data
-    keywords_category_name = keywords_category_name.lower().strip() if keywords_category_name else ""
-    category_prefix = f"{keywords_category_name}_" if keywords_category_name else ""
-    keywords_list = load_json_data(path_json, "keywords").get(f"{category_prefix}keywords", [])
-
-    # Validate data availability
-    if not keywords_list or not keywords_category_name:
-        keywords_list, keywords_category_name = [], ""
-
-    # Process both conferences and journals
-    for cj, ia in zip(["conferences", "journals"], ["inproceedings", "article"]):
-        # Skip if specific type requested and doesn't match
-        if conferences_or_journals and conferences_or_journals.lower() != cj:
-            continue
-
-        # Update JSON data
-        json_dict = update_json_file(path_json, cj)
-        if not json_dict:
-            continue
-
-        # Generate data dictionaries
-        path_spidered_cj = os.path.join(path_spidered_bibs, cj.title())
-        generater = GenerateDataDict(cj, ia, json_dict, for_vue, path_spidered_cj)
-        publisher_meta_dict, publisher_abbr_meta_dict, keyword_abbr_meta_dict = generater.generate()
-        if not (publisher_meta_dict and publisher_abbr_meta_dict and keyword_abbr_meta_dict):
-            continue
-
-        # Initialize writer and save all markdown files
-        _path_output = os.path.join(path_output, f"{cj.title()}")
-        save_data = WriteDataToMd(
-            cj, ia, publisher_meta_dict, publisher_abbr_meta_dict, keyword_abbr_meta_dict, _path_output
-        )
-        # Save various documentation files
-        save_data.save_introductions()
-        save_data.save_categories(keywords_category_name, keywords_list)
-        save_data.save_categories_separate_keywords()
-
-        save_data.save_publishers()
-        save_data.save_publishers_separate_abbrs()
-
-        save_data.save_statistics(keywords_category_name, keywords_list)
-        save_data.save_statistics_separate_abbrs()
-
-    return None