pyformatjson 0.0.3__tar.gz → 0.2.0__tar.gz

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

@@ -1,16 +1,17 @@
 Metadata-Version: 2.4
 Name: pyformatjson
-Version: 0.0.3
+Version: 0.2.0
 Summary: pyformatjson
 License: GPL-3.0-or-later
-Keywords: Python,json
+Keywords: Python,Json
 Author: NextAI
 Author-email: nextartifintell@gmail.com
 Maintainer: NextAI
 Maintainer-email: nextartifintell@gmail.com
-Requires-Python: >=3.13
+Requires-Python: >=3.12
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules

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

@@ -16,7 +16,7 @@ def load_json_data(path_json: str, filename: str) -> Dict:
 
     Args:
         path_json (str): Directory path containing the JSON file.
-        filename (str): Name of the JSON file (without .json extension).
+        filename (str): Name of the JSON file (with .json extension).
 
     Returns:
         Dict: The loaded JSON data as a dictionary, or empty dict if file not found
@@ -27,7 +27,7 @@ def load_json_data(path_json: str, filename: str) -> Dict:
         {"publisher1": {"conferences": {...}}}
     """
     try:
-        file_path = os.path.join(path_json, f"{filename}.json")
+        file_path = os.path.join(path_json, filename)
         if not os.path.exists(file_path):
             return {}
 
@@ -35,11 +35,11 @@ def load_json_data(path_json: str, filename: str) -> Dict:
             return json.load(file)
 
     except Exception as e:
-        print(f"Error loading {filename}.json: {e}")
+        print(f"Error loading {filename}: {e}")
         return {}
 
 
-def update_json_file(path_root: str, conferences_or_journals: str) -> Dict[str, Any]:
+def update_json_file(full_json_cj: str, conferences_or_journals: str) -> Dict[str, Any]:
     """Update and format JSON file containing conference/journal data.
 
     This function loads JSON data, processes and formats text fields by splitting
@@ -47,21 +47,14 @@ def update_json_file(path_root: str, conferences_or_journals: str) -> Dict[str,
     saves the updated data back to the file.
 
     Args:
-        path_root (str): Root directory path containing the JSON file.
+        full_json_cj (str): Full path to the conferences/journals JSON file
         conferences_or_journals (str): Type of publication ('conferences' or 'journals').
 
     Returns:
         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)
+    json_dict = load_json_data(os.path.dirname(full_json_cj), os.path.basename(full_json_cj))
 
     # Process and format text fields in JSON data.
     for pub in json_dict:
@@ -87,8 +80,7 @@ def update_json_file(path_root: str, conferences_or_journals: str) -> Dict[str,
 
     # Save updated JSON
     if json_dict:
-        path_file = os.path.join(path_root, f"{conferences_or_journals}.json")
-        with open(path_file, "w", encoding="utf-8") as f:
+        with open(full_json_cj, "w", encoding="utf-8") as f:
             f.write(json.dumps(json_dict, indent=4, sort_keys=True, ensure_ascii=True))
 
     return json_dict

pyformatjson-0.2.0/pyformatjson/main.py

@@ -0,0 +1,106 @@
+# 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(
+    full_json_c: str,
+    full_json_j: str,
+    full_json_k: str,
+    path_output: str,
+    path_spidered_bibs: Optional[str] = None,
+    keywords_category_name: str = "",
+    for_vue: bool = True,
+) -> None:
+    """Generate comprehensive markdown documentation for academic publications.
+
+    This function serves as the main entry point for processing conference and journal
+    data from JSON files and generating various markdown documentation outputs. It
+    handles both conference and journal data processing, creates categorized outputs,
+    and generates statistics and publisher information files.
+
+    The function processes three types of JSON files:
+    - Conference data (full_json_c)
+    - Journal data (full_json_j)
+    - Keywords data (full_json_k)
+
+    Args:
+        full_json_c (str): Full path to the conferences JSON file containing
+            conference publication data.
+        full_json_j (str): Full path to the journals JSON file containing
+            journal publication data.
+        full_json_k (str): Full path to the keywords JSON file containing
+            keyword categorization data.
+        path_output (str): Output directory path where all generated markdown
+            files will be saved.
+        path_spidered_bibs (Optional[str], optional): Directory path containing
+            spidered BibTeX files for additional data processing. Defaults to None.
+        keywords_category_name (str, optional): Category name for filtering
+            keywords. If provided, only keywords from this category will be
+            processed. Defaults to "".
+        for_vue (bool, optional): Whether to generate Vue.js-compatible format
+            for date calculations and dynamic content. Defaults to True.
+
+    Returns:
+        None: This function does not return a value.
+    """
+    # Standardize all paths
+    full_json_c = os.path.expanduser(full_json_c)
+    full_json_j = os.path.expanduser(full_json_j)
+    full_json_k = os.path.expanduser(full_json_k)
+
+    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_json = load_json_data(os.path.dirname(full_json_k), os.path.basename(full_json_k))
+    keywords_list = keywords_json.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"]):
+        # Update JSON data
+        json_dict = {}
+        if cj == "conferences":
+            json_dict = update_json_file(full_json_c, cj)
+        elif cj == "journals":
+            json_dict = update_json_file(full_json_j, 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

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

@@ -252,12 +252,26 @@ class GenerateDataDict(object):
         return full_name, abbr_name
 
     def _extract_homepage_url(self, abbr_dict: dict):
-        """Extract and clean homepage URL."""
+        """Extract and clean homepage URL.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+
+        Returns:
+            str: The first valid homepage URL, or empty string if none found.
+        """
         urls = [u.strip() for u in abbr_dict.get("urls_homepage", []) if u.strip()]
         return urls[0] if urls else ""
 
     def _format_period_with_dblp(self, abbr_dict: dict):
-        """Format publication period with DBLP link if available."""
+        """Format publication period with DBLP link if available.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+
+        Returns:
+            str: Formatted period string with optional DBLP link.
+        """
         start_year = abbr_dict.get("year_start", "")
         end_year = abbr_dict.get("year_end", "")
 
@@ -273,16 +287,41 @@ class GenerateDataDict(object):
         return period
 
     def _extract_text_content(self, abbr_dict: dict, key: str):
-        """Extract and clean text content from dictionary."""
+        """Extract and clean text content from dictionary.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+            key (str): Key to extract text content from.
+
+        Returns:
+            List[str]: List of non-empty text content.
+        """
         return [text for text in abbr_dict.get(key, []) if text.strip()]
 
     def _extract_first_url(self, abbr_dict: dict, key: str):
-        """Extract first URL from a list in dictionary."""
+        """Extract first URL from a list in dictionary.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+            key (str): Key to extract URLs from.
+
+        Returns:
+            str: The first valid URL, or empty string if none found.
+        """
         urls = [url.strip() for url in abbr_dict.get(key, []) if url.strip()]
         return urls[0].split(",")[0] if urls else ""
 
     def _process_keywords(self, abbr_dict: dict):
-        """Process keywords and convert to Google search URLs."""
+        """Process keywords and convert to Google search URLs.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+
+        Returns:
+            tuple: A tuple containing (keywords, keywords_url) where keywords
+                is a sorted list of unique keywords and keywords_url is a list
+                of markdown-formatted Google search links.
+        """
         keywords_dict = abbr_dict.get("keywords_dict", {})
 
         # Clean and sort keywords
@@ -315,13 +354,28 @@ class GenerateDataDict(object):
         return all_keywords, keywords_url
 
     def _format_top_score(self, abbr_dict: dict):
-        """Format top score with optional early access link."""
+        """Format top score with optional early access link.
+
+        Args:
+            abbr_dict (dict): Dictionary containing publication data.
+
+        Returns:
+            str: Formatted top score with optional early access link.
+        """
         is_top = "True" if abbr_dict.get("score_top", False) else "False"
         url_early_access = abbr_dict.get("url_early_access", "")
         return self._format_link(is_top, url_early_access)
 
     def _format_link(self, text, url):
-        """Format text as markdown link if URL provided."""
+        """Format text as markdown link if URL provided.
+
+        Args:
+            text (str): Text to display.
+            url (str): URL to link to.
+
+        Returns:
+            str: Markdown-formatted link or plain text if no URL provided.
+        """
         return f"[{text}]({url})" if url else text
 
     def _generate_table_row(
@@ -521,6 +575,19 @@ class GenerateDataDict(object):
 
     # Mermaid data
     def generate_mermaid_data(self, publisher: str, abbr: str, inproceedings_or_article: str):
+        """Generate Mermaid diagram data from spidered README files.
+
+        This method reads spidered data from README files and generates
+        Mermaid chart configuration for visualizing publication statistics.
+
+        Args:
+            publisher (str): Publisher name.
+            abbr (str): Publication abbreviation.
+            inproceedings_or_article (str): Publication type.
+
+        Returns:
+            List[str]: Mermaid chart configuration lines, or empty list if no data found.
+        """
         path_spidered_cj = self.path_spidered_cj if self.path_spidered_cj else ""
         path_readme = os.path.join(path_spidered_cj, publisher, abbr, inproceedings_or_article)
         full_readme = os.path.expanduser(os.path.join(path_readme, "README.md"))

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

@@ -1,12 +1,23 @@
 # coding=utf-8
 
 import os
+import re
 from typing import List
 
 from ..core._base import standardize_path
 from .generate_dict import conference_journal_header
 
 
+def create_safe_filename(text: str) -> str:
+    """Create a safe filename across all platforms."""
+    # Remove or replace invalid characters
+    safe_text = re.sub(r'[<>:"/\\|?*]', '_', text)
+    # Remove leading/trailing spaces and dots
+    safe_text = safe_text.strip(' .')
+    # Ensure it's not empty
+    return safe_text if safe_text else "unnamed"
+
+
 def conference_journal_informations():
     """Generate informational content for conferences and journals.
 
@@ -132,6 +143,22 @@ class WriteDataToMd(object):
 
     # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
     def _default_or_customized_keywords(self, keywords_category_name: str, keywords_list: List[str]):
+        """Get default or customized keywords based on category and provided list.
+
+        This method returns either a filtered list of keywords based on the provided
+        category and keyword list, or all available keywords sorted alphabetically.
+
+        Args:
+            keywords_category_name (str): The category name for keywords filtering.
+            keywords_list (List[str]): List of keywords to filter by.
+
+        Returns:
+            List[str]: List of keywords to use for processing.
+
+        Example:
+            >>> writer._default_or_customized_keywords("ai", ["machine learning", "deep learning"])
+            ["deep learning", "machine learning"]
+        """
         keywords = list(self.keyword_abbr_meta_dict.keys())
 
         # Get and sort publication types
@@ -191,6 +218,18 @@ class WriteDataToMd(object):
         return None
 
     def save_categories_separate_keywords(self) -> None:
+        """Save publications categorized by keywords in separate files.
+
+        This method generates individual markdown files for each keyword category,
+        creating separate files for better organization and navigation.
+
+        Returns:
+            None: This method does not return a value.
+
+        Note:
+            Each keyword gets its own file saved as '{keyword}.md' in the
+            Categories_{type} subdirectory.
+        """
         conference_header, journal_header = conference_journal_header()
 
         # Add publications for each category
@@ -212,7 +251,7 @@ class WriteDataToMd(object):
             # Write keyword-specific file
             path_key = standardize_path(os.path.join(self.path_output, f"Categories_{self.cj.title()}"))
             # Create safe filename by replacing invalid characters
-            safe_keyword = "".join(c if c.isalnum() or c in "-_" else "_" for c in keyword)
+            safe_keyword = create_safe_filename(keyword).replace(" ", "_")
             with open(os.path.join(path_key, f"{safe_keyword}.md"), "w", encoding="utf-8") as f:
                 f.writelines(data_list)
 
@@ -264,6 +303,19 @@ class WriteDataToMd(object):
         return None
 
     def save_publishers_separate_abbrs(self) -> None:
+        """Save detailed publisher information in separate files.
+
+        This method generates individual markdown files for each publisher,
+        containing detailed information about their conferences/journals,
+        including about sections, remarks, and statistics.
+
+        Returns:
+            None: This method does not return a value.
+
+        Note:
+            Each publisher gets its own file saved as '{publisher}.md' in the
+            Publishers_{type} subdirectory.
+        """
         conference_header, journal_header = conference_journal_header()
         for pub in self.publisher_meta_dict:
             data_list = [f"# {pub}\n\n"]
@@ -317,6 +369,21 @@ class WriteDataToMd(object):
 
     # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
     def save_statistics(self, keywords_category_name: str, keywords_list: List[str]) -> None:
+        """Save statistics overview file for keywords.
+
+        This method generates a markdown file containing statistics overview
+        for all keywords with links to their detailed pages.
+
+        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 'Statistics_{type}_{category}.md' in the output directory.
+        """
         data_list = [
             f"# Statistics of keywords in {self.cj.title()}\n\n",
             "| |keywords|Separate Links|\n",
@@ -327,8 +394,9 @@ class WriteDataToMd(object):
         # Add publications for each category
         for keyword in self._default_or_customized_keywords(keywords_category_name, keywords_list):
             # 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)"
+            safe_keyword = create_safe_filename(keyword).replace(" ", "_")
+            ll = os.path.join("data", self.cj.title(), f"Statistics_{self.cj.title()}", f"{safe_keyword}.md")
+            local_url = f"[Link]({ll})"
 
             # Create table row
             row = f"| {idx} | {keyword} | {local_url} |\n"
@@ -344,6 +412,18 @@ class WriteDataToMd(object):
         return None
 
     def save_statistics_separate_abbrs(self) -> None:
+        """Save detailed statistics for each keyword in separate files.
+
+        This method generates individual markdown files for each keyword,
+        containing detailed statistics and publication information.
+
+        Returns:
+            None: This method does not return a value.
+
+        Note:
+            Each keyword gets its own file saved as '{keyword}.md' in the
+            Statistics_{type} subdirectory.
+        """
         conference_header, journal_header = conference_journal_header()
 
         # Add publications for each category
@@ -371,7 +451,7 @@ class WriteDataToMd(object):
             # Write publisher-specific file
             path_pub = standardize_path(os.path.join(self.path_output, f"Statistics_{self.cj.title()}"))
             # Create safe filename by replacing invalid characters
-            safe_keyword = "".join(c if c.isalnum() or c in "-_" else "_" for c in keyword)
+            safe_keyword = create_safe_filename(keyword).replace(" ", "_")
             with open(os.path.join(path_pub, f"{safe_keyword}.md"), "w", encoding="utf-8") as f:
                 f.writelines(data_list)
 

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyformatjson"
-version = "0.0.3"
+version = "0.2.0"
 description = "pyformatjson"
 license = "GPL-3.0-or-later"
 authors = ["NextAI <nextartifintell@gmail.com>"]
@@ -9,11 +9,11 @@ readme = ["README.md"]
 homepage = "https://github.com/NextArtifIntell/pyformatjson"
 repository = "https://github.com/NextArtifIntell/pyformatjson"
 documentation = "https://github.com/NextArtifIntell/pyformatjson"
-keywords = ["Python", "json"]
+keywords = ["Python", "Json"]
 classifiers = ["Topic :: Software Development :: Libraries :: Python Modules"]
 
 [tool.poetry.dependencies]
-python = ">=3.13"
+python = ">=3.12"
 
 [tool.poetry.group.dev.dependencies]
 mypy = "^1.18.2"
@@ -23,6 +23,7 @@ pydocstyle = "^6.3.0"
 flake8 = "^7.3.0"
 isort = "^6.0.1"
 black = "^25.9.0"
+pyright = "^1.1.405"
 
 
 [tool.pyright]

pyformatjson-0.0.3/pyformatjson/main.py

@@ -1,155 +0,0 @@
-# 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