BibexPy 2.0.0__py3-none-any.whl

bibex_core/scp2xlsx.py

@@ -0,0 +1,235 @@
+import pandas as pd
+import re
+import os
+from typing import List, Union
+
+
+def abbrev_title(title: str) -> str:
+    # This function can be used to abbreviate journal names
+    # Simple version for now
+    return title.replace('.', '').upper()
+
+
+def labelling(data: pd.DataFrame) -> pd.DataFrame:
+    """Converts column labels to standard format"""
+
+    df_tag = pd.DataFrame([
+        ["Abbreviated Source Title", "JI"],
+        ["Affiliations", "C1"],
+        ["Authors", "AU"],
+        ["Author Names", "AU"],
+        ["Author full names", "AF"],
+        ["Source title", "SO"],
+        ["Titles", "TI"],
+        ["Title", "TI"],
+        ["Publication Year", "PY"],
+        ["Year", "PY"],
+        ["Volume", "VL"],
+        ["Issue", "IS"],
+        ["Page count", "PP"],
+        ["Cited by", "TC"],
+        ["DOI", "DI"],
+        ["Link", "URL"],
+        ["Abstract", "AB"],
+        ["Author Keywords", "DE"],
+        ["Indexed Keywords", "ID"],
+        ["Index Keywords", "ID"],
+        ["Funding Details", "FU"],
+        ["Funding Texts", "FX"],
+        ["Funding Text 1", "FX"],
+        ["References", "CR"],
+        ["Correspondence Address", "RP"],
+        ["Publisher", "PU"],
+        ["Open Access", "OA"],
+        ["Language of Original Document", "LA"],
+        ["Document Type", "DT"],
+        ["Source", "DB"],
+        ["EID", "UT"]
+    ], columns=['orig', 'tag'])
+
+    # Mevcut sütun isimlerini al
+    label = pd.DataFrame({'orig': data.columns})
+
+    # Eşleştirme yap
+    label = label.merge(df_tag, on='orig', how='left')
+
+    # Eşleşmeyen sütunlar için orijinal ismi kullan
+    label['tag'] = label['tag'].fillna(label['orig'])
+
+    # Sütun isimlerini güncelle
+    data.columns = label['tag']
+
+    return data
+
+
+def csvScopus2df(files: Union[str, List[str]]) -> pd.DataFrame:
+    """
+    Reads and processes Scopus CSV files
+
+    Parameters:
+    -----------
+    files : str or list of str
+        Path to CSV files to process
+
+    Returns:
+    --------
+    pd.DataFrame
+        Processed data frame
+    """
+
+    if isinstance(files, str):
+        files = [files]
+
+    all_data = []
+
+    for i, file in enumerate(files):
+        try:
+            # Read CSV file
+            df = pd.read_csv(file,
+                             dtype=str,  # Read all columns as string
+                             na_values='',  # Mark empty values as NA
+                             keep_default_na=False,  # Don't use default NA values
+                             encoding='utf-8')  # Use UTF-8 encoding
+
+            # Replace NA values with empty string
+            df = df.fillna('')
+
+            if i > 0:
+                # Find common columns
+                common_cols = list(set(df.columns) & set(all_data[0].columns))
+                # Merge using only common columns
+                all_data.append(df[common_cols])
+            else:
+                all_data.append(df)
+
+        except Exception as e:
+            print(f"Error: Failed to read file {file}: {str(e)}")
+            continue
+
+    if not all_data:
+        raise ValueError("No files could be read!")
+
+    # Merge all dataframes
+    DATA = pd.concat(all_data, ignore_index=True)
+
+    # Organize column labels
+    DATA = labelling(DATA)
+
+    # Clean author names
+    if 'AU' in DATA.columns:
+        DATA['AU'] = DATA['AU'].str.replace('.', '', regex=False)
+        DATA['AU'] = DATA['AU'].str.replace(',', ';', regex=False)
+
+    # Store raw institution information
+    if 'C1' not in DATA.columns:
+        DATA['C1'] = ''
+
+    # Process journal abbreviations
+    if 'JI' in DATA.columns:
+        DATA['J9'] = DATA['JI'].str.replace('.', '', regex=False)
+    else:
+        if 'SO' in DATA.columns:
+            DATA['J9'] = DATA['SO'].apply(abbrev_title)
+            DATA['JI'] = DATA['J9']
+
+    # Store DI and URL values (before converting to uppercase)
+    di_values = DATA.get('DI', None)
+    url_values = DATA.get('URL', None)
+
+    # Convert all string columns to uppercase
+    for col in DATA.columns:
+        if DATA[col].dtype == 'object':
+            DATA[col] = DATA[col].str.upper()
+
+    # Restore DI and URL values
+    if di_values is not None:
+        DATA['DI'] = di_values
+    if url_values is not None:
+        DATA['URL'] = url_values
+
+    return DATA
+
+
+def save_to_excel(file_paths: Union[str, List[str]], output_path: str) -> bool:
+    """
+    Processes Scopus CSV files and saves as Excel file
+
+    Parameters:
+    -----------
+    file_paths : str or list of str
+        Path to CSV files to process
+    output_path : str
+        Path to output Excel file
+
+    Returns:
+    --------
+    bool
+        Whether the operation was successful
+    """
+    try:
+        # Convert data
+        df = csvScopus2df(file_paths)
+
+        # Save as Excel
+        df.to_excel(output_path, index=False)
+        print(f"Data successfully saved to {output_path}")
+        return True
+    except Exception as e:
+        print(f"Error occurred: {str(e)}")
+        return False
+
+
+if __name__ == "__main__":
+    try:
+        # Show current working directory
+        print(f"Current working directory: {os.getcwd()}")
+
+        while True:
+            # Get file names from user
+            print("\nEnter the full path or file names of Scopus CSV files separated by commas")
+            print("Example 1: data1.csv,data2.csv")
+            print("Example 2: C:/Users/data1.csv,D:/Data/data2.csv")
+            print("(Type 'q' to quit)")
+
+            input_str = input().strip()
+            if input_str.lower() == 'q':
+                print("Program terminating...")
+                break
+
+            input_files = [f.strip() for f in input_str.split(',')]
+
+            # Get output file name
+            print("\nEnter the name or full path of the output Excel file")
+            print("Example 1: output.xlsx")
+            print("Example 2: C:/Users/output.xlsx")
+            output_file = input().strip()
+
+            # Check file extensions
+            input_files = [f if f.endswith('.csv') else f + '.csv' for f in input_files]
+            if not output_file.endswith('.xlsx'):
+                output_file += '.xlsx'
+
+            # Check if files exist
+            missing_files = [f for f in input_files if not os.path.exists(f)]
+            if missing_files:
+                print("\nError: The following files were not found:")
+                for f in missing_files:
+                    print(f"- {f}")
+                print("\nPlease check the file names and try again.")
+                continue
+
+            # Process files and save to Excel
+            print("\nProcessing files...")
+            success = save_to_excel(input_files, output_file)
+            if success:
+                print("\nOperation completed successfully!")
+                print(f"Result file: {os.path.abspath(output_file)}")
+
+            # Ask if user wants to continue
+            print("\nDo you want to process more files? (Y/N)")
+            if input().strip().upper() != 'Y':
+                print("Program terminating...")
+                break
+
+    except Exception as e:
+        print(f"\nAn unexpected error occurred: {str(e)}")

bibex_core/wos2xlsx.py

@@ -0,0 +1,159 @@
+import pandas as pd
+import re
+import os
+
+
+def remove_strange_char(text):
+    # Remove strange characters
+    return re.sub(r'[^\x00-\x7F]+', '', text)
+
+
+def safe_str_replace(x, old, new):
+    # Safe string replacement operation
+    if pd.isna(x):
+        return x
+    try:
+        return str(x).replace(old, new)
+    except:
+        return x
+
+
+def isi2df(D):
+    # Remove empty lines and strange characters
+    D = [line for line in D if len(line.strip()) > 1]
+    D = [remove_strange_char(line) for line in D]
+
+    # Remove lines starting with FN and VR
+    D = [line for line in D if not line.startswith(('FN ', 'VR '))]
+
+    # Combine lines starting with spaces with the label of the previous line
+    for i in range(1, len(D)):
+        if D[i].startswith('   '):
+            D[i] = D[i - 1][:3] + D[i][3:]
+
+    # Find starting indices of documents
+    papers = [i for i, line in enumerate(D) if line.startswith('PT ')]
+    nP = len(papers)
+
+    if nP == 0:
+        raise ValueError("No valid ISI format found. Please check your file.")
+
+    # Calculate number of lines for each document
+    row_papers = []
+    for i in range(len(papers) - 1):
+        row_papers.append(papers[i + 1] - papers[i])
+    row_papers.append(len(D) - papers[-1])
+
+    # Create document number for each line
+    num_papers = []
+    for i, count in enumerate(row_papers):
+        num_papers.extend([i + 1] * count)
+
+    # Create DataFrame
+    data = {
+        'Tag': [line[:3].strip() for line in D],
+        'content': [line[3:].strip() for line in D],
+        'Paper': num_papers
+    }
+    df = pd.DataFrame(data)
+
+    # Combine Tag and content
+    df = df.groupby(['Paper', 'Tag'])['content'].apply('---'.join).reset_index()
+
+    # Pivot operation
+    df = df.pivot(index='Paper', columns='Tag', values='content').reset_index()
+
+    # Check mandatory fields
+    mandatory_tags = ['AU', 'DE', 'C1', 'RP', 'CR', 'PY', 'SO', 'TI', 'TC']
+    missing_tags = [tag for tag in mandatory_tags if tag not in df.columns]
+    if missing_tags:
+        print("\nWarning: Some mandatory metadata fields are missing. Bibliometrix functions may not work properly!")
+        print("Missing fields:", missing_tags)
+
+    # Fields that should be separated by commas
+    comma_tags = ['AU', 'AF', 'CR']
+    for tag in comma_tags:
+        if tag in df.columns:
+            df[tag] = df[tag].apply(lambda x: safe_str_replace(x, '---', ';'))
+
+    # Replace --- with space for other fields
+    other_tags = [col for col in df.columns if col not in comma_tags]
+    for tag in other_tags:
+        if tag in df.columns:
+            df[tag] = df[tag].apply(lambda x: safe_str_replace(x, '---', ' ').strip() if pd.notnull(x) else x)
+
+    # Add C1raw column
+    if 'C1' in df.columns:
+        df['C1raw'] = df['C1'].copy()
+        # Remove author information in square brackets
+        df['C1'] = df['C1'].apply(lambda x: re.sub(r'\[.*?\]', '', str(x)) if pd.notnull(x) else x)
+        df['C1'] = df['C1'].apply(lambda x: safe_str_replace(x, '.', '.;') if pd.notnull(x) else x)
+
+    # Add database information
+    df['DB'] = 'ISI'
+
+    # Clean commas in author names
+    if 'AU' in df.columns:
+        df['AU'] = df['AU'].apply(lambda x: safe_str_replace(x, ',', ' ').strip() if pd.notnull(x) else x)
+
+    # Convert all string columns to uppercase except DI
+    di_col = None
+    if 'DI' in df.columns:
+        di_col = df['DI'].copy()
+
+    for col in df.columns:
+        if df[col].dtype == 'object':
+            df[col] = df[col].apply(lambda x: str(x).upper() if pd.notnull(x) else x)
+
+    if di_col is not None:
+        df['DI'] = di_col
+
+    # Remove Paper column
+    df = df.drop('Paper', axis=1)
+
+    return df
+
+
+def save_to_excel(file_path, output_path):
+    try:
+        # Read file
+        with open(file_path, 'r', encoding='utf-8') as file:
+            lines = file.readlines()
+
+        if not lines:
+            raise ValueError("File is empty!")
+
+        # Convert data
+        df = isi2df(lines)
+
+        # Save as Excel
+        df.to_excel(output_path, index=False)
+        print(f"Data successfully saved to {output_path}")
+        return True
+    except Exception as e:
+        print(f"Error occurred: {str(e)}")
+        return False
+
+
+if __name__ == "__main__":
+    # Get file names from user
+    print("Enter the name of the ISI format file (e.g., data.txt):")
+    input_file = input().strip()
+
+    print("Enter the name of the output Excel file (e.g., output.xlsx):")
+    output_file = input().strip()
+
+    # Check file extensions
+    if not input_file.endswith(('.txt', '.isi')):
+        input_file += '.txt'
+    if not output_file.endswith('.xlsx'):
+        output_file += '.xlsx'
+
+    # Check if file exists
+    if not os.path.exists(input_file):
+        print(f"Error: File {input_file} not found!")
+    else:
+        # Process file and save to Excel
+        success = save_to_excel(input_file, output_file)
+        if success:
+            print("\nOperation completed successfully!")

bibex_core/xlsx2vos.py

@@ -0,0 +1,185 @@
+import pandas as pd
+from tqdm import tqdm  # İlerleme çubuğu için tqdm kütüphanesi
+
+def convert_excel_to_wos(input_excel_path, output_txt_path):
+    # Excel dosyasını pandas kullanarak aç
+    df = pd.read_excel(input_excel_path)
+
+    # Başlıklara göre sütun isimlerini eşleştir
+    desired_columns = {
+        "PT": "PT",           # Publication Type
+        "AU": "AU",           # Authors
+        "AF": "AF",           # Author Full Names
+        "TI": "TI",           # Title
+        "SO": "SO",           # Source
+        "LA": "LA",           # Language
+        "DT": "DT",           # Document Type
+        "DE": "DE",           # Keywords
+        "ID": "ID",           # Keywords Plus
+        "AB": "AB",           # Abstract
+        "C1": "C1",        # Author Address
+        "C3": "C3",           # Additional Address
+        "RP": "RP",           # Reprint Address
+        "EM": "EM",           # Email
+        "FU": "FU",           # Funding
+        "FX": "FX",           # Funding Text
+        "CR": "CR",       # Cited References
+        "NR": "NR",           # Number of References
+        "TC": "TC",           # Times Cited
+        "Z9": "Z9",           # Total Times Cited
+        "U1": "U1",           # Usage Count (Last 180 Days)
+        "U2": "U2",           # Usage Count (Since 2013)
+        "PU": "PU",           # Publisher
+        "PI": "PI",           # Publisher City
+        "PA": "PA",           # Publisher Address
+        "SN": "SN",           # ISSN
+        "EI": "ISSN",         # Electronic ISSN
+        "J9": "J9",           # 29-Character Source Abbreviation
+        "JI": "JI",           # ISO Source Abbreviation
+        "PD": "PD",           # Publication Date
+        "PY": "PY",           # Year Published
+        "VL": "VL",           # Volume
+        "AR": "Art. No.",     # Article Number
+        "DI": "DI",           # DOI
+        "EA": "EA",           # Early Access Date
+        "PG": "PG",           # Page Count
+        "WC": "WC",           # Web of Science Categories
+        "WE": "WE",           # Web of Science Index
+        "SC": "SC",           # Research Areas
+        "GA": "GA",           # Document Delivery Number
+        "UT": "UT",           # Accession Number
+        "DA": "DA"            # Date of Export
+    }
+
+    # Değerleri saklamak için boş listeler oluştur
+    values_dict = {column: [] for column in desired_columns}
+
+    # Verileri başlıklara göre al
+    for idx, row in df.iterrows():
+        for key, header_name in desired_columns.items():
+            cell_value = row.get(header_name, "")
+            values_dict[key].append(cell_value if pd.notna(cell_value) else "")
+
+    with open(output_txt_path, 'w', encoding='utf-8') as file:
+        # Dosya başlangıcı (bir kere)
+        file.write("FN Clarivate Analytics Web of Science\n")
+        file.write("VR 1.0\n\n")
+
+        # Her kayıt için bilgileri dosyaya yaz
+        for idx in range(len(df)):
+            # Her kayıt PT ile başlar
+            pt_value = values_dict["PT"][idx] if values_dict["PT"][idx] else "J"
+            file.write(f"PT {pt_value}\n")
+
+            # AU (Author) bilgisi
+            au = values_dict["AU"][idx]
+            if au:
+                au_list = au.split(';')  # Yazarları ayır
+                formatted_au_list = [author.strip() for author in au_list if author.strip()]
+                file.write(f"AU {formatted_au_list[0]}\n")  # AU belirtecinin ilk satırını AU satırına yaz
+                for author in formatted_au_list[1:]:
+                    file.write(f"   {author}\n")  # Diğer yazarları alt satırlara yaz ve önde üç boşluk bırak
+            else:
+                file.write("AU \n")
+
+            # AF (Author Full Name) bilgisi
+            af = values_dict["AF"][idx]
+            if af:
+                af_list = af.split(';')  # Yazar tam isimlerini ayır
+                file.write(f"AF {af_list[0].strip()}\n")  # AF belirtecinin ilk satırını AF satırına yaz
+                for author_full in af_list[1:]:
+                    file.write(f"   {author_full.strip()}\n")  # Diğer isimleri alt satırlara yaz ve önde üç boşluk bırak
+            else:
+                file.write("AF \n")
+
+            # Diğer makale bilgilerini yaz
+            file.write(f"TI {values_dict['TI'][idx]}\n")  # Makale başlığı
+            file.write(f"SO {values_dict['SO'][idx]}\n")  # Kaynak başlık (Source)
+            file.write(f"LA {values_dict['LA'][idx]}\n")  # Dil bilgisi (Language)
+            file.write(f"DT {values_dict['DT'][idx]}\n")  # Belge türü (Document Type)
+            file.write(f"DE {values_dict['DE'][idx]}\n")  # Anahtar kelimeler (Keywords)
+            file.write(f"ID {values_dict['ID'][idx]}\n")  # Keywords Plus
+            file.write(f"AB {values_dict['AB'][idx]}\n")  # Özet (Abstract)
+
+            # C1 (Author Address) information - Each address on a new line
+            c1 = values_dict['C1'][idx]
+            af = values_dict['AF'][idx]
+
+            if c1 and af:
+                # Split authors and addresses
+                authors = [a.strip() for a in af.split(';') if a.strip()]
+                addresses = [addr.strip() for addr in c1.split(';') if addr.strip()]
+                
+                # If we have both authors and addresses
+                if authors and addresses:
+                    # İlk satır için "C1" kullan
+                    file.write(f"C1 [{authors[0]}] {addresses[0]}\n")
+                    
+                    # Diğer satırlar için "   " ile başla
+                    current_addr_idx = 1
+                    
+                    # Normal eşleşmeleri yaz
+                    for i in range(1, min(len(authors), len(addresses))):
+                        file.write(f"   [{authors[i]}] {addresses[i]}\n")
+                        current_addr_idx = i + 1
+                        
+                    # Eğer fazla yazar varsa, son adresle eşleştir
+                    if len(authors) > len(addresses):
+                        last_address = addresses[-1]
+                        for i in range(current_addr_idx, len(authors)):
+                            file.write(f"   [{authors[i]}] {last_address}\n")
+            else:
+                file.write("C1 \n")
+
+            file.write(f"C3 {values_dict['C3'][idx]}\n")  # Other address information
+            file.write(f"RP {values_dict['RP'][idx]}\n")  # Reprint Address
+            file.write(f"EM {values_dict['EM'][idx]}\n")  # Email Address
+            file.write(f"FU {values_dict['FU'][idx]}\n")  # Funding Information
+            file.write(f"FX {values_dict['FX'][idx]}\n")  # Funding Text
+
+            # CR (Cited References) information - from CR_raw column
+            cr = values_dict['CR'][idx]
+            if cr:
+                cr_list = [ref.strip() for ref in cr.split(';') if ref.strip()]  # Filter empty references
+                if cr_list:
+                    # Writing process
+                    file.write(f"CR {cr_list[0]}\n")  # First reference
+                    for ref in cr_list[1:]:
+                        file.write(f"   {ref}\n")  # Other references start with 3 spaces
+            else:
+                file.write("CR \n")
+
+            # Diğer gerekli bilgileri yaz
+            file.write(f"NR {values_dict['NR'][idx]}\n")  # Atıf sayısı (Number of References)
+            file.write(f"TC {values_dict['TC'][idx]}\n")  # Toplam atıf sayısı (Times Cited)
+            file.write(f"Z9 {values_dict['Z9'][idx]}\n")  # Total Times Cited
+            file.write(f"U1 {values_dict['U1'][idx]}\n")  # Usage Count (Last 180 Days)
+            file.write(f"U2 {values_dict['U2'][idx]}\n")  # Usage Count (Since 2013)
+            file.write(f"PU {values_dict['PU'][idx]}\n")  # Publisher
+            file.write(f"PI {values_dict['PI'][idx]}\n")  # Publisher City
+            file.write(f"PA {values_dict['PA'][idx]}\n")  # Publisher Address
+            file.write(f"SN {values_dict['SN'][idx]}\n")  # ISSN
+            file.write(f"EI {values_dict['EI'][idx]}\n")  # Electronic ISSN
+            file.write(f"J9 {values_dict['J9'][idx]}\n")  # 29-Character Source Abbreviation
+            file.write(f"JI {values_dict['JI'][idx]}\n")  # ISO Source Abbreviation
+            file.write(f"PD {values_dict['PD'][idx]}\n")  # Publication Date
+            file.write(f"PY {values_dict['PY'][idx]}\n")  # Year Published
+            file.write(f"VL {values_dict['VL'][idx]}\n")  # Volume
+            file.write(f"AR {values_dict['AR'][idx]}\n")  # Article Number
+            file.write(f"DI {values_dict['DI'][idx]}\n")  # DOI
+            file.write(f"EA {values_dict['EA'][idx]}\n")  # Early Access Date
+            file.write(f"PG {values_dict['PG'][idx]}\n")  # Page Count
+            file.write(f"WC {values_dict['WC'][idx]}\n")  # Web of Science Categories
+            file.write(f"WE {values_dict['WE'][idx]}\n")  # Web of Science Index
+            file.write(f"SC {values_dict['SC'][idx]}\n")  # Research Areas
+            file.write(f"GA {values_dict['GA'][idx]}\n")  # Document Delivery Number
+            file.write(f"UT {values_dict['UT'][idx]}\n")  # Accession Number
+            file.write(f"DA {values_dict['DA'][idx]}\n")  # Date of Export
+
+            # Her kayıt ER ile biter
+            file.write("ER\n\n")
+
+        # Dosya sonu
+        file.write("EF\n")
+
+    print(f"Successfully converted file to WoS format: '{output_txt_path}'")

bibexpy/__init__.py

@@ -0,0 +1,9 @@
+"""BibexPy v2 — self-hosted bibliometric data preparation tool.
+
+Son kullanıcı bu paketi `pip install bibexpy` ile kurar ve `bibexpy` komutuyla
+çalıştırır. Gömülü FastAPI sunucusu + Next.js static UI tek pakette gelir;
+Node.js / npm gerektirmez.
+"""
+
+__version__ = "2.0.0"
+__all__ = ["__version__"]

bibexpy/__main__.py

@@ -0,0 +1,6 @@
+"""`python -m bibexpy` desteği — cli.main()'e yönlendirir."""
+
+from bibexpy.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bibexpy/_server/__init__.py

@@ -0,0 +1 @@
+"""BibexPy gömülü FastAPI sunucusu (build-time kopya). Runtime sys.path'e eklenir."""