pyformatjson 0.0.1__py3-none-any.whl

pyformatjson/core/_base.py

@@ -0,0 +1,103 @@
+# 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/core/update_json.py

@@ -0,0 +1,90 @@
+# coding=utf-8
+
+import json
+import os
+from typing import Any, Dict
+
+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."""
+    try:
+        file_path = os.path.join(path_json, f"{filename}.json")
+        if not os.path.exists(file_path):
+            return {}
+
+        with open(file_path, "r", encoding="utf-8") as file:
+            return json.load(file)
+
+    except Exception as e:
+        print(f"Error loading {filename}.json: {e}")
+        return {}
+
+
+def update_json_file(path_root: str, conferences_or_journals: str) -> Dict[str, Any]:
+    """
+    Update and format JSON file containing conference/journal data.
+
+    Args:
+        path_root (str): Root directory path
+        conferences_or_journals (str): Type of publication ('conferences' or 'journals')
+
+    Returns:
+        Dict[str, Any]: Processed JSON data
+    """
+    # Load Json Data
+    json_dict = load_json_data(path_root, conferences_or_journals)
+
+    # Process and format text fields in JSON data.
+    for pub in json_dict:
+        for flag in ["txt_abouts", "txt_remarks"]:
+            data_list = [p for p in json_dict[pub].get(flag, []) if p.strip()]
+            temps = []
+            for line in split_data_list(r"(\n+)", ["".join(data_list)], "next"):
+                temps.extend(split_text_by_length(line, 105))
+            if temps:
+                json_dict[pub].update({flag: temps})
+
+        for abbr in json_dict[pub][conferences_or_journals]:
+            for flag in ["txt_abouts", "txt_remarks"]:
+                data_list = [i for i in json_dict[pub][conferences_or_journals][abbr].get(flag, []) if i.strip()]
+                temps = []
+                for line in split_data_list(r"(\n+)", ["".join(data_list)], "next"):
+                    temps.extend(split_text_by_length(line, 97))
+                if temps:
+                    json_dict[pub][conferences_or_journals][abbr].update({flag: temps})
+
+    # Check for duplicate abbreviations
+    _check_duplicate_abbr(json_dict, conferences_or_journals)
+
+    # 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:
+            f.write(json.dumps(json_dict, indent=4, sort_keys=True, ensure_ascii=True))
+
+    return json_dict
+
+
+def _check_duplicate_abbr(json_dict: Dict[str, Any], conferences_or_journals: str) -> None:
+    """
+    Check for duplicate abbreviations in the data.
+
+    Args:
+        json_dict: JSON data dictionary
+        conferences_or_journals (str): Type of publication ('conferences' or 'journals')
+
+    Raises:
+        ValueError: If duplicate abbreviations are found
+    """
+    abbr_list = []
+
+    for pub in json_dict:
+        if conferences_or_journals in json_dict[pub]:
+            for abbr in json_dict[pub][conferences_or_journals]:
+                if abbr in abbr_list:
+                    raise ValueError(f"Duplicate abbreviation: {abbr} in {conferences_or_journals} {pub}")
+                abbr_list.append(abbr)
+
+    return None

pyformatjson/main.py

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

pyformatjson/tools/generate_dict.py

@@ -0,0 +1,456 @@
+# coding=utf-8
+
+import os
+import re
+from datetime import datetime
+from typing import Optional
+
+
+def conference_journal_header():
+    o = "|Publishers|Full/Homepage|Abbr/About|"
+    t = "|-         |-            |-         |"
+    conference_header = [
+        f"{o}Acronym/Archive|Period/DBLP|Top|CCF|Submission|Days Left|Main Conf.|Days Left|Location|Keywords/Google|\n",
+        f"{t}-              |-          |-  |-  |-         |-        |          |-        |-       |-              |\n",
+    ]
+    journal_header = [
+        f"{o}Acronym/Issues|Period/DBLP|Top/Early|CCF|CAS|JCR|IF|Keywords/Google|\n",
+        f"{t}-             |-          |-        |-  |-  |-  |- |-              |\n",
+    ]
+    return conference_header, journal_header
+
+
+class GenerateDataDict(object):
+    def __init__(
+        self,
+        conferences_or_journals: str,
+        inproceedings_or_article: str,
+        json_dict: dict,
+        for_vue: bool = True,
+        path_spidered_conferences_or_journals: Optional[str] = None,
+    ) -> None:
+        self.cj = conferences_or_journals
+        self.ia = inproceedings_or_article
+        self.json_dict = json_dict
+
+        self.path_spidered_cj = path_spidered_conferences_or_journals
+        self.for_vue = for_vue
+
+    def generate(self):
+        """
+        Generate publisher metadata and keyword-based publication information.
+
+        Returns:
+            tuple: Contains two dictionaries:
+                - publisher_meta_abbr_dict: Publisher metadata and abbreviations
+                - publication_keyword_row_info_dict: Keyword-indexed publication info
+        """
+        publisher_meta_dict, keyword_abbr_meta_dict, publisher_abbr_meta_dict = {}, {}, {}
+
+        for publisher in self.json_dict:
+            # Extract and clean about texts
+            abouts = [p for p in self.json_dict[publisher].get("txt_abouts", []) if p.strip()]
+
+            # Extract and clean about URLs
+            urls_about = [p.strip() for p in self.json_dict[publisher].get("urls_about", []) if p.strip()]
+
+            # Get full names
+            names_full = self.json_dict[publisher].get("names_full", [])
+
+            # Get homepage URLs
+            urls_homepage = self.json_dict[publisher].get("urls_homepage", [])
+
+            # Extract and clean conference/journal URLs
+            urls_cj = [url.strip() for url in self.json_dict[publisher].get(f"urls_{self.cj}", []) if url.strip()]
+
+            # Create publisher URL with markdown formatting if homepage exists
+            publisher_url = f"[{publisher}]({urls_homepage[0]})" if urls_homepage else publisher
+
+            # Create full name URL with markdown formatting if available
+            if names_full:
+                full_url = f"[{names_full[0]}]({urls_homepage[0]})" if urls_homepage else names_full[0]
+            else:
+                full_url = publisher
+
+            # Extract and clean remarks
+            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 "",
+            })
+
+            # Process each abbreviation (conference/journal)
+            for abbr in self.json_dict[publisher][self.cj]:
+                abbr_dict = self.json_dict[publisher][self.cj][abbr]
+
+                # Get conference/journal info and keywords
+                temp_dict, keywords = self.conference_or_journal(publisher_url, abbr, abbr_dict)
+
+                # Generate mermaid diagram data
+                mermaid = self.generate_mermaid_data(publisher, abbr, self.ia)
+
+                publisher_abbr_meta_dict.setdefault(publisher, {}).setdefault(abbr, {}).update(temp_dict)
+                publisher_abbr_meta_dict.setdefault(publisher, {}).setdefault(abbr, {}).update({"statistics": mermaid})
+
+                # Index by keywords for quick lookup
+                for keyword in keywords:
+                    keyword_abbr_meta_dict.setdefault(keyword, {}).setdefault(abbr, {}).update(temp_dict)
+                    keyword_abbr_meta_dict.setdefault(keyword, {}).setdefault(abbr, {}).update({"statistics": mermaid})
+
+        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.
+
+        Args:
+            publisher_url: Publisher's URL
+            abbr: Abbreviation identifier
+            abbr_dict: Dictionary containing publication details
+
+        Returns:
+            dict: Contains formatted about text, remarks, and table row
+            list: Sorted list of keywords
+        """
+        # Validate full and abbreviated names match in length
+        self._validate_name_lengths(abbr_dict)
+
+        # Extract basic information
+        full_name, abbr_name = self._extract_full_abbr_names(abbr_dict)
+        url_home = self._extract_homepage_url(abbr_dict)
+        period = self._format_period_with_dblp(abbr_dict)
+
+        # Extract text content
+        abouts = self._extract_text_content(abbr_dict, "txt_abouts")
+        remarks = self._extract_text_content(abbr_dict, "txt_remarks")
+        url_about = self._extract_first_url(abbr_dict, "urls_about")
+
+        # Process keywords with Google search links
+        keywords, keywords_url = self._process_keywords(abbr_dict)
+
+        # Format top score with early access link if available
+        top = self._format_top_score(abbr_dict)
+
+        # 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
+        )
+
+        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."""
+        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")
+
+    def _extract_full_abbr_names(self, abbr_dict: dict):
+        """Extract full and abbreviated names from dictionary."""
+        # 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", ""))
+        abbr_name = abbr_dict.get("names_abbr", [""])[0]
+        return full_name, abbr_name
+
+    def _extract_homepage_url(self, abbr_dict: dict):
+        """Extract and clean homepage URL."""
+        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."""
+        start_year = abbr_dict.get("year_start", "")
+        end_year = abbr_dict.get("year_end", "")
+
+        # Create period string (e.g., "2020 - 2023" or "2020 -")
+        period = f"{start_year} - {end_year}" if start_year and end_year else f"{start_year} -" if start_year else ""
+
+        # Add DBLP link if acronym available
+        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})'
+
+        return period
+
+    def _extract_text_content(self, abbr_dict: dict, key: str):
+        """Extract and clean text content from dictionary."""
+        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."""
+        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."""
+        keywords_dict = abbr_dict.get("keywords_dict", {})
+
+        # Clean and sort keywords
+        cleaned_keywords = {}
+        for category, words in keywords_dict.items():
+            if category.strip():
+                sorted_words = sorted(set([word.strip() for word in words if word.strip()]))
+                cleaned_keywords[category.strip()] = sorted_words
+
+        # Flatten keywords and remove duplicates
+        all_keywords = []
+        for category, words in cleaned_keywords.items():
+            if words:
+                all_keywords.extend(words)
+            else:
+                all_keywords.append(category)
+        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
+        ]
+
+        # For category
+        # Flatten keywords and remove duplicates
+        all_keywords = []
+        for category, words in cleaned_keywords.items():
+            all_keywords.extend(words)
+            all_keywords.append(category)
+        all_keywords = sorted(set(all_keywords))
+
+        return all_keywords, keywords_url
+
+    def _format_top_score(self, abbr_dict: dict):
+        """Format 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."""
+        return f"[{text}]({url})" if url else text
+
+    def _generate_table_row(
+        self, publisher_url, full_name, abbr_name, url_home, url_about, period, top, keywords, abbr, abbr_dict
+    ):
+        """Generate appropriate table row based on publication type."""
+        if self.cj == "conferences":
+            return self._generate_for_conference(
+                publisher_url, full_name, abbr_name, url_home, url_about, period, top, keywords, abbr, abbr_dict
+            )
+        else:
+            return self._generate_for_journal(
+                publisher_url, full_name, abbr_name, url_home, url_about, period, top, keywords, abbr, abbr_dict
+            )
+
+    # Conferences
+    def _generate_for_conference(
+        self, publisher_url, full_name, abbr_name, url_home, url_about, period, top, keywords, abbr, abbr_dict
+    ):
+        """
+        Generate a markdown table row for conference information.
+
+        Args:
+            publisher_url: URL of the publisher
+            full_name: Full name of the conference
+            abbr_name: Abbreviated name of the conference
+            url_home: Homepage URL
+            url_about: About page URL
+            period: Conference period/frequency
+            top: Conference ranking/tier
+            keywords: List of keywords
+            abbr: Conference abbreviation
+            abbr_dict: Dictionary containing conference details
+
+        Returns:
+            str: Formatted markdown table row
+        """
+        # Get archive URL and format link
+        archive_url = self._extract_first_url(abbr_dict, "urls_archive")
+        archive_display = self._format_link(abbr, archive_url)
+
+        # Process conference dates
+        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
+        )
+
+        # 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
+        )
+
+    def _process_conference_dates(self, abbr_dict):
+        """Parse and return conference dates."""
+        # Parse abstract due date
+        abstract_due = None
+        if due_str := abbr_dict.get("conf_abstract_due", "").strip():
+            abstract_due = datetime.strptime(due_str, "%d/%m/%Y").date()
+
+        # Parse conference start date
+        start_date = None
+        if start_str := abbr_dict.get("conf_date_start", "").strip():
+            start_date = datetime.strptime(start_str, "%d/%m/%Y").date()
+
+        # Get today's date
+        today = datetime.strptime(datetime.now().strftime("%d/%m/%Y"), "%d/%m/%Y").date()
+
+        return abstract_due, start_date, today
+
+    def _format_date_indicators(self, abstract_due, start_date, today):
+        """Format date indicators for display."""
+        abstract_indicator, start_indicator = "", ""
+
+        if self.for_vue:
+            # Vue.js template format
+            if abstract_due:
+                abstract_indicator = f"**{{{{ diffDate('{abstract_due}') }}}}**"
+            if start_date:
+                start_indicator = f"**{{{{ diffDate('{start_date}') }}}}**"
+        else:
+            # Standard day count format
+            if abstract_due:
+                abstract_indicator = (abstract_due - today).days if today <= abstract_due else "Expired"
+            if start_date:
+                start_indicator = (start_date - today).days if today <= start_date else "Expired"
+
+        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
+    ):
+        """Construct conference table row string."""
+        # Format date strings
+        abstract_date_str = abstract_due.strftime("%d/%m/%Y") if abstract_due else ""
+        start_date_str = start_date.strftime("%d/%m/%Y") if start_date else ""
+
+        # Format start date with link if available
+        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)}|"
+
+    # Journals
+    def _generate_for_journal(
+        self, publisher_url, full_name, abbr_name, url_home, url_about, period, top, keywords, abbr, abbr_dict
+    ):
+        """
+        Generate a markdown table row for journal information.
+
+        Args:
+            publisher_url: URL of the publisher
+            full_name: Full name of the journal
+            abbr_name: Abbreviated name of the journal
+            url_home: Homepage URL
+            url_about: About page URL
+            period: Publication period/frequency
+            top: Journal ranking/tier
+            keywords: List of keywords
+            abbr: Journal abbreviation
+            abbr_dict: Dictionary containing journal details
+
+        Returns:
+            str: Formatted markdown table row
+        """
+        # Get issues URL and format link
+        issues_url = self._extract_first_url(abbr_dict, "urls_issues")
+        issues_display = self._format_link(abbr, issues_url)
+
+        # 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
+        )
+
+    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)}|"
+
+    # Mermaid data
+    def generate_mermaid_data(self, publisher: str, abbr: str, inproceedings_or_article: str):
+        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"))
+        if not os.path.exists(full_readme):
+            return []
+
+        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:
+            data_list = file.readlines()
+        for line in data_list:
+            if mch := regex.search(line):
+                data_dict.setdefault(mch.group(1), []).append(mch.group(2))
+        data_dict = {year: sum([int(n) for n in data_dict[year]]) for year in data_dict}
+
+        # Mermaid
+        if len(data_dict) != 0:
+            mermaid = ["```mermaid\n"]
+            mermaid.extend(
+                [
+                    '---\n',
+                    'config:\n',
+                    '    xyChart:\n',
+                    '        width: 1200\n',
+                    '        height: 600\n',
+                    '    themeVariables:\n',
+                    '        xyChart:\n',
+                    '            titleColor: "#ff0000"\n',
+                    '---\n'
+                ]
+            )
+            mermaid.extend(["xychart-beta\n", f'    title "{abbr}"\n'])
+
+            x_axis, bar, line = [], [], []
+            for year in data_dict:
+                x_axis.append(int(year))
+                bar.append(data_dict[year])
+                line.append(data_dict[year])
+
+            idx = next((i for i, year in enumerate(x_axis) if year >= 2000), len(x_axis))
+            x_axis, bar, line = x_axis[idx:], bar[idx:], line[idx:]
+
+            mermaid.append(f"    x-axis {x_axis}\n")
+            mermaid.append('    y-axis "Number of Papers"\n')
+            mermaid.append(f"    bar {bar}\n")
+            mermaid.append(f"    line {line}\n")
+            mermaid.append("```\n")
+
+        return mermaid

pyformatjson/tools/write_dict.py

@@ -0,0 +1,284 @@
+# coding=utf-8
+
+import os
+from typing import List
+
+from ..core._base import standardize_path
+from .generate_dict import conference_journal_header
+
+
+def conference_journal_informations():
+    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"
+    ]
+    journal_inf = []
+    return conference_inf, journal_inf
+
+
+class WriteDataToMd(object):
+    """Class to write publication data to Markdown files."""
+
+    def __init__(
+        self,
+        conferences_or_journals: str,
+        inproceedings_or_article: str,
+        publisher_meta_dict: dict,
+        publisher_abbr_meta_dict: dict,
+        keyword_abbr_meta_dict: dict,
+        path_output: str,
+    ) -> None:
+        """Initialize with publication data and output path."""
+        self.cj = conferences_or_journals  # "conferences" or "journals"
+        self.ia = inproceedings_or_article  # "inproceedings" or "article"
+        self.publisher_meta_dict = publisher_meta_dict
+        self.publisher_abbr_meta_dict = publisher_abbr_meta_dict
+        self.keyword_abbr_meta_dict = keyword_abbr_meta_dict
+        self.path_output = standardize_path(path_output)
+
+        self._default_inf = [
+            "- The data for TOP, CCF, CAS, JCR, and IF are sourced from [easyScholar](https://www.easyscholar.cc/).\n\n"
+        ]
+
+    def save_introductions(self) -> None:
+        """Save introduction file with all conferences/journals list."""
+        conference_header, journal_header = conference_journal_header()
+        conference_inf, journal_inf = conference_journal_informations()
+
+        data_list = [f"# {self.cj.title()}\n\n"]
+        data_list.extend(self._default_inf)
+
+        # Add appropriate headers based on type
+        if self.cj.lower() == "conferences":
+            data_list.extend(conference_inf)
+            data_list.append("|  " + conference_header[0])
+            data_list.append("|- " + conference_header[1])
+        else:
+            data_list.extend(journal_inf)
+            data_list.append("|  " + journal_header[0])
+            data_list.append("|- " + journal_header[1])
+
+        # Add all publications to table
+        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']
+                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:
+            f.writelines(data_list)
+
+    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
+    def _default_or_customized_keywords(self, keywords_category_name: str, keywords_list: List[str]):
+        keywords = list(self.keyword_abbr_meta_dict.keys())
+
+        # Get and sort publication types
+        if keywords_category_name and keywords_list:
+            _keywords = []
+            for keyword in keywords_list:
+                if keyword in keywords:
+                    _keywords.append(keyword)
+            return _keywords
+        else:
+            # default
+            return sorted(keywords)
+
+    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
+    def save_categories(self, keywords_category_name: str, keywords_list: List[str]) -> None:
+        """Save publications categorized by keywords."""
+        conference_header, journal_header = conference_journal_header()
+        data_list = [f"# {self.cj.title()}\n\n"]
+        data_list.extend(self._default_inf)
+
+        # Add publications for each category
+        for keyword in self._default_or_customized_keywords(keywords_category_name, keywords_list):
+            data_list.append(f"## {keyword}\n\n")
+
+            # Add appropriate header
+            if self.cj == "conferences":
+                data_list.extend(conference_header)
+            else:
+                data_list.extend(journal_header)
+
+            # Add all publications in this category
+            for abbr in self.keyword_abbr_meta_dict[keyword]:
+                data_list.append(self.keyword_abbr_meta_dict[keyword][abbr]["row_inf"] + "\n")
+            data_list.append("\n")
+
+        # 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:
+            f.writelines(data_list)
+
+        return None
+
+    def save_categories_separate_keywords(self) -> None:
+        conference_header, journal_header = conference_journal_header()
+
+        # Add publications for each category
+        for keyword in self.keyword_abbr_meta_dict:
+            data_list = [f"# {keyword}\n\n"]
+            data_list.extend(self._default_inf)
+
+            # Add appropriate header
+            if self.cj == "conferences":
+                data_list.extend(conference_header)
+            else:
+                data_list.extend(journal_header)
+
+            # Add all publications in this category
+            for abbr in self.keyword_abbr_meta_dict[keyword]:
+                data_list.append(self.keyword_abbr_meta_dict[keyword][abbr]["row_inf"] + "\n")
+            data_list.append("\n")
+
+            # 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:
+                f.writelines(data_list)
+
+        return None
+
+    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
+    def save_publishers(self) -> None:
+        """Save publisher overview file with basic information."""
+        data_list_pub = [
+            f"# Introductions of Publishers and {self.cj.title()}\n\n",
+            "| |Publishers|About US|Conferences/Journals|Separate Links|\n",
+            "|-|-         |-       |-                   |-             |\n"
+        ]
+        idx = 1
+
+        # Add each publisher to table
+        for pub in self.publisher_meta_dict:
+            meta = self.publisher_meta_dict[pub]
+
+            full_name_url, about_url, cj_url, local_url = "", "", "", ""
+            if x := meta.get("full_name_url", ""):
+                full_name_url = x
+            if x := meta.get("url_conferences_or_journals", ""):
+                cj_url = x
+            if pub_intr_urls := meta.get("urls_about", []):
+                about_url = f"[About US]({pub_intr_urls[0]})"
+
+            local_url = f"[{pub}](data/{self.cj.title()}/Publishers_{self.cj.title()}/{pub}.md)"
+
+            # Create table row
+            row = f"| {idx} | {full_name_url} | {about_url} | {cj_url} | {local_url} |\n"
+            data_list_pub.append(row)
+            idx += 1
+
+        # Write to file
+        with open(os.path.join(self.path_output, f"Publishers_{self.cj.title()}.md"), "w") as f:
+            f.writelines(data_list_pub)
+        return None
+
+    def save_publishers_separate_abbrs(self) -> None:
+        conference_header, journal_header = conference_journal_header()
+        for pub in self.publisher_meta_dict:
+            data_list = [f"# {pub}\n\n"]
+            data_list.extend(self._default_inf)
+            meta = self.publisher_meta_dict[pub]
+
+            # Add about and remarks sections
+            for flag in ["txt_remarks", "txt_abouts"]:
+                if temps := meta.get(flag, []):
+                    temps[-1] = f"{temps[-1].rstrip()}\n\n"
+                if temps:
+                    data_list.append(f"## {flag.title()}\n\n")
+                    data_list.extend(temps)
+
+            # Add each conference/journal abbreviation
+            if pub not in self.publisher_abbr_meta_dict:
+                continue
+
+            for abbr in self.publisher_abbr_meta_dict[pub]:
+                data_list.append(f"## {abbr}\n\n")
+
+                # Add appropriate header
+                if self.cj == "conferences":
+                    data_list.extend(conference_header)
+                else:
+                    data_list.extend(journal_header)
+
+                # Add row information
+                row_info = self.publisher_abbr_meta_dict[pub][abbr]["row_inf"]
+                data_list.append(f'{row_info}\n\n')
+
+                # Add remarks and about for this abbreviation
+                for flag in ["txt_remarks", "txt_abouts"]:
+                    if temps := self.publisher_abbr_meta_dict[pub][abbr].get(flag, []):
+                        temps[-1] = f"{temps[-1].rstrip()}\n\n"
+                    if temps:
+                        data_list.append(f"### {flag.split('_')[-1].title()}\n\n")
+                        data_list.extend(temps)
+
+                # Add statistics if available
+                if statistics := self.publisher_abbr_meta_dict[pub][abbr].get("statistics", []):
+                    data_list.extend(statistics)
+                    data_list.append("\n")
+
+            # 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:
+                f.writelines(data_list)
+
+        return None
+
+    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
+    def save_statistics(self, keywords_category_name: str, keywords_list: List[str]) -> None:
+        data_list = [
+            f"# Statistics of keywords in {self.cj.title()}\n\n",
+            "| |keywords|Separate Links|\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 table row
+            row = f"| {idx} | {keyword} | {local_url} |\n"
+            data_list.append(row)
+            idx += 1
+
+        # 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:
+            f.writelines(data_list)
+        return None
+
+    def save_statistics_separate_abbrs(self) -> None:
+        conference_header, journal_header = conference_journal_header()
+
+        # Add publications for each category
+        for keyword in self.keyword_abbr_meta_dict:
+            data_list = [f"# {keyword}\n\n"]
+
+            for abbr in self.keyword_abbr_meta_dict[keyword]:
+                data_list.append(f"## {abbr}\n\n")
+
+                # Add appropriate header
+                if self.cj == "conferences":
+                    data_list.extend(conference_header)
+                else:
+                    data_list.extend(journal_header)
+
+                # Add row information
+                row_info = self.keyword_abbr_meta_dict[keyword][abbr]["row_inf"]
+                data_list.append(f'{row_info}\n\n')
+
+                # Add statistics if available
+                if statistics := self.keyword_abbr_meta_dict[keyword][abbr].get("statistics", []):
+                    data_list.extend(statistics)
+                    data_list.append("\n")
+
+            # 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:
+                f.writelines(data_list)
+
+        return None

pyformatjson-0.0.1.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: pyformatjson
+Version: 0.0.1
+Summary: pyformatjson
+License: GPL-3.0-or-later
+Keywords: Python,json
+Author: NextAI
+Author-email: nextartifintell@gmail.com
+Maintainer: NextAI
+Maintainer-email: nextartifintell@gmail.com
+Requires-Python: >=3.13
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Documentation, https://github.com/NextArtifIntell/pyformatjson
+Project-URL: Homepage, https://github.com/NextArtifIntell/pyformatjson
+Project-URL: Repository, https://github.com/NextArtifIntell/pyformatjson
+Description-Content-Type: text/markdown
+
+# PyFormatJson
+

pyformatjson-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pyformatjson/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyformatjson/core/_base.py,sha256=rLu503M9cgbIaByP5zTo7JZo-8HZoBfPyb1y7_Btkcs,2878
+pyformatjson/core/update_json.py,sha256=AdvwIrlZoqE-36UxUumcUQ3DuSc1SSBJUGF2T550YZc,3119
+pyformatjson/main.py,sha256=7nypq1inVyjI8tj_rL_BsnLGsUuWtSdhgBSPkkw5In8,3179
+pyformatjson/tools/generate_dict.py,sha256=naQfKk9gqXZaTeC93wBCLmJ8a9wusRMMiOVqRCOIZ0o,19408
+pyformatjson/tools/write_dict.py,sha256=HpkJYbxdxxAxS_3WMBw-QyKuZ0IXWus1-EUEcPkW8Jw,11930
+pyformatjson-0.0.1.dist-info/METADATA,sha256=IEPUNlD8AXPHlK2l-eHX_4-8whZa2FVgn0VOGCSArRY,855
+pyformatjson-0.0.1.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+pyformatjson-0.0.1.dist-info/RECORD,,

pyformatjson-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.0
+Root-Is-Purelib: true
+Tag: py3-none-any