G2PInsight 1.0.4__tar.gz → 1.0.7__tar.gz

{g2pinsight-1.0.4 → g2pinsight-1.0.7}/G2PInsight/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '1.0.4'
+__version__ = '1.0.7'
 __author__ = 'chenrf'
 __email__ = '12024128035@stu.ynu.edu.cn'

{g2pinsight-1.0.4 → g2pinsight-1.0.7}/G2PInsight/bin/font_utils.py

@@ -27,7 +27,7 @@ def detect_available_fonts() -> Tuple[Optional[str], Optional[str]]:
     try:
         mpl_fonts = _collect_matplotlib_font_names()
         chinese_font_candidates = ['SimHei', 'SimSun', 'Microsoft YaHei', 'KaiTi', 'FangSong', 'STSong', 'STKaiti']
-        english_fonts = ['Arial', 'DejaVu Sans', 'Liberation Sans', 'Helvetica', 'Times New Roman', 'Calibri']
+        english_fonts = ['Times New Roman', 'Arial', 'DejaVu Sans', 'Liberation Sans', 'Helvetica', 'Calibri']
         chinese_font = None
         for font_name in chinese_font_candidates:
             if font_name in mpl_fonts:
@@ -38,32 +38,60 @@ def detect_available_fonts() -> Tuple[Optional[str], Optional[str]]:
             if font_name in mpl_fonts:
                 english_font = font_name
                 break
-        if not chinese_font:
-            chinese_font = 'DejaVu Sans'
         if not english_font:
             english_font = 'DejaVu Sans'
+        # Only keep a Chinese default when a real CJK face exists; otherwise prefer English.
+        if not chinese_font:
+            chinese_font = None
         return (chinese_font, english_font)
     except Exception:
-        return ('DejaVu Sans', 'DejaVu Sans')
+        return (None, 'DejaVu Sans')
 
 def setup_matplotlib_font(chinese_font: Optional[str]=None, english_font: Optional[str]=None) -> None:
     try:
         mpl = _load_module('matplotlib')
         mpl.use('Agg')
         plt = _load_module('matplotlib.pyplot')
-        if chinese_font is None or english_font is None:
+        if chinese_font is None and english_font is None:
             chinese_font, english_font = detect_available_fonts()
-        default_font = chinese_font if chinese_font else english_font
-        plt.rcParams['font.sans-serif'] = [default_font, english_font, 'DejaVu Sans']
+        elif chinese_font is None or english_font is None:
+            detected_cn, detected_en = detect_available_fonts()
+            if chinese_font is None:
+                chinese_font = detected_cn
+            if english_font is None:
+                english_font = detected_en
+        # Prefer real Chinese face when present; otherwise use English (e.g. Times New Roman).
+        default_font = chinese_font or english_font or 'DejaVu Sans'
+        fallback_en = english_font or 'DejaVu Sans'
+        serif_prefer = {'Times New Roman', 'Times', 'Liberation Serif', 'DejaVu Serif', 'Georgia'}
+        if default_font in serif_prefer or (not chinese_font and fallback_en in serif_prefer):
+            face = default_font if default_font in serif_prefer else fallback_en
+            plt.rcParams['font.family'] = 'serif'
+            plt.rcParams['font.serif'] = [face, 'Times New Roman', 'DejaVu Serif', 'Liberation Serif']
+            plt.rcParams['font.sans-serif'] = [fallback_en, 'DejaVu Sans']
+            # STIX math glyphs (subscripts etc.) — Times New Roman lacks Unicode ₁₀
+            plt.rcParams['mathtext.fontset'] = 'stix'
+        else:
+            plt.rcParams['font.family'] = 'sans-serif'
+            plt.rcParams['font.sans-serif'] = [default_font, fallback_en, 'DejaVu Sans']
+            if english_font:
+                plt.rcParams['font.serif'] = [english_font, 'DejaVu Serif', 'Liberation Serif']
+            plt.rcParams['mathtext.fontset'] = 'dejavusans'
         plt.rcParams['axes.unicode_minus'] = False
     except Exception:
         pass
 
 def setup_plotly_font(chinese_font: Optional[str]=None, english_font: Optional[str]=None) -> dict:
     try:
-        if chinese_font is None or english_font is None:
+        if chinese_font is None and english_font is None:
             chinese_font, english_font = detect_available_fonts()
-        default_font = chinese_font if chinese_font else english_font
+        elif chinese_font is None or english_font is None:
+            detected_cn, detected_en = detect_available_fonts()
+            if chinese_font is None:
+                chinese_font = detected_cn
+            if english_font is None:
+                english_font = detected_en
+        default_font = chinese_font or english_font or 'Arial'
         return {'family': default_font, 'size': 12}
     except Exception:
         return {'family': 'Arial', 'size': 12}

{g2pinsight-1.0.4 → g2pinsight-1.0.7}/G2PInsight/bin/gemma_gwas.py

@@ -19,7 +19,7 @@ def _get_plink_executable() -> str:
         return str(_bundled_plink)
     found = shutil.which('plink')
     if found:
-        logger.info(f'Using system PLINK executable from PATH: {found}')
+        logger.debug(f'Using system PLINK executable from PATH: {found}')
         return found
     raise FileNotFoundError(f'PLINK executable not found. Checked bundled path: {_bundled_plink} and system PATH.')
 
@@ -28,7 +28,7 @@ def _get_gemma_executable() -> str:
         return str(_bundled_gemma)
     found = shutil.which('gemma')
     if found:
-        logger.info(f'Using system GEMMA executable from PATH: {found}')
+        logger.debug(f'Using system GEMMA executable from PATH: {found}')
         return found
     raise FileNotFoundError(f'GEMMA executable not found. Checked bundled path: {_bundled_gemma} and system PATH.')
 plink_executable = _get_plink_executable()
@@ -45,7 +45,7 @@ def validate_input_files(input_prefix: str) -> None:
             missing_files.append(file_path)
     if missing_files:
         raise FileNotFoundError(f"Missing PLINK binary files: {', '.join(missing_files)}")
-    logger.info(f'Input file validation passed: {input_prefix}')
+    logger.debug(f'Input file validation passed: {input_prefix}')
 
 def validate_phenotype_file(phenotype_file: str) -> pd.DataFrame:
     if not isinstance(phenotype_file, str) or not phenotype_file.strip():
@@ -56,14 +56,14 @@ def validate_phenotype_file(phenotype_file: str) -> pd.DataFrame:
         pheno_df = pd.read_csv(phenotype_file, sep='\\s+', header=None, usecols=[0, 1], skipinitialspace=True)
         pheno_df.columns = ['IID', 'PHENO']
         if pheno_df['IID'].isnull().any() or pheno_df['PHENO'].isnull().any():
-            logger.warning('The first two columns in the phenotype file contain missing values')
+            logger.debug('The first two columns in the phenotype file contain missing values')
         return pheno_df
     except Exception as e:
         raise RuntimeError(f'Failed to read phenotype file: {str(e)}')
 
 def run_shell_command(cmd: list, step_name: str) -> None:
     cmd_str = ' '.join(cmd)
-    logger.info(f'[RUN] {step_name}: {cmd_str}')
+    logger.debug(f'[RUN] {step_name}: {cmd_str}')
     result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding='utf-8')
     stderr_content = ''
     if result.stderr:
@@ -80,14 +80,14 @@ def run_shell_command(cmd: list, step_name: str) -> None:
         if result.returncode == 0:
             error_keywords = ['ERROR', 'FATAL', 'FAIL', 'Exception', 'Traceback']
             if any((keyword in stderr_content.upper() for keyword in error_keywords)):
-                logger.warning(f'stderr (potential issue): {stderr_content}')
+                logger.debug(f'stderr (potential issue): {stderr_content}')
             else:
-                logger.info(f'stderr (informational): {stderr_content}')
+                logger.debug(f'stderr (informational): {stderr_content}')
         else:
             logger.error(f'stderr: {stderr_content}')
     if result.returncode != 0:
         raise RuntimeError(f'{step_name} failed with return code: {result.returncode}')
-    logger.info(f'[DONE] {step_name}')
+    logger.debug(f'[DONE] {step_name}')
 
 def plink_quality_control(input_prefix: str, output_prefix: str) -> None:
     cmd = [plink_executable, '--bfile', input_prefix, '--maf', '0.05', '--geno', '0.2', '--allow-extra-chr', '--allow-no-sex', '--make-bed', '--out', output_prefix]
@@ -106,7 +106,7 @@ def merge_phenotype_to_fam(pheno_df: pd.DataFrame, fam_file: str) -> None:
     new_fam_df.to_csv(fam_file, sep=' ', header=False, index=False)
     matched = (fam_df['PHENO'] != '-9').sum()
     total = len(fam_df)
-    logger.info(f'Phenotype matching completed: {matched}/{total} samples matched (-9 used for missing phenotypes)')
+    logger.debug(f'Phenotype matching completed: {matched}/{total} samples matched (-9 used for missing phenotypes)')
 
 def calculate_pca(input_prefix: str, output_prefix: str) -> None:
     cmd = [plink_executable, '--bfile', input_prefix, '--pca', '5', '--allow-extra-chr', '--allow-no-sex', '--out', output_prefix]
@@ -118,7 +118,7 @@ def filter_valid_samples(pheno_df: pd.DataFrame, fam_file: str, output_sample_fi
     fam_df['IID'] = fam_df['IID'].astype(str).str.strip()
     valid_df = fam_df[fam_df['IID'].isin(valid_iids)][['FID', 'IID']]
     valid_df.to_csv(output_sample_file, sep=' ', header=False, index=False)
-    logger.info(f'Valid samples saved to: {output_sample_file} (n={len(valid_df)})')
+    logger.debug(f'Valid samples saved to: {output_sample_file} (n={len(valid_df)})')
 
 def filter_plink_samples(input_prefix: str, sample_file: str, output_prefix: str) -> None:
     cmd = [plink_executable, '--bfile', input_prefix, '--keep', sample_file, '--allow-extra-chr', '--allow-no-sex', '--make-bed', '--out', output_prefix]
@@ -131,13 +131,13 @@ def filter_pca_by_samples(pca_file: str, sample_file: str, output_pca_file: str)
     pca_df['key'] = list(zip(pca_df[0].astype(str).str.strip(), pca_df[1].astype(str).str.strip()))
     filtered_df = pca_df[pca_df['key'].isin(valid_set)].drop('key', axis=1)
     filtered_df.to_csv(output_pca_file, sep=' ', header=False, index=False)
-    logger.info(f'Filtered PCA saved to: {output_pca_file} (n={len(filtered_df)} samples)')
+    logger.debug(f'Filtered PCA saved to: {output_pca_file} (n={len(filtered_df)} samples)')
 
 def extract_pca_covariates(pca_file: str, output_cov_file: str) -> None:
     pca_df = pd.read_csv(pca_file, sep='\\s+', header=None)
     cov_df = pca_df.iloc[:, 2:]
     cov_df.to_csv(output_cov_file, sep=' ', header=False, index=False)
-    logger.info(f'PCA covariates saved to: {output_cov_file} (PCs={cov_df.shape[1]})')
+    logger.debug(f'PCA covariates saved to: {output_cov_file} (PCs={cov_df.shape[1]})')
 
 def calculate_kinship_matrix(genotype_prefix: str, output_prefix: str) -> str:
     base_prefix = Path(output_prefix).name
@@ -153,15 +153,15 @@ def run_gemma_gwas(genotype_prefix: str, kinship_file: str, cov_file: str, outpu
     base_prefix = Path(output_prefix).name
     gwas_prefix = f'{base_prefix}_gwas'
     current_dir = os.getcwd()
-    logger.info(f'GWAS working directory: {current_dir}')
-    logger.info(f'GWAS output prefix: {gwas_prefix} (results expected under {current_dir}/output/)')
+    logger.debug(f'GWAS working directory: {current_dir}')
+    logger.debug(f'GWAS output prefix: {gwas_prefix} (results expected under {current_dir}/output/)')
     cmd = [gemma_executable, '-bfile', genotype_prefix, '-k', kinship_file, '-c', cov_file, '-lmm', '1', '-o', gwas_prefix]
     run_shell_command(cmd, 'GWAS association analysis')
     expected_result_file = Path(current_dir) / 'output' / f'{gwas_prefix}.assoc.txt'
     if expected_result_file.exists():
-        logger.info(f'GWAS result file generated: {expected_result_file}')
+        logger.debug(f'GWAS result file generated: {expected_result_file}')
     else:
-        logger.warning(f'GWAS result file not found at expected path: {expected_result_file}')
+        logger.debug(f'GWAS result file not found at expected path: {expected_result_file}')
 
 def run_complete_gwas_pipeline(input_plink_prefix: str, phenotype_file: str, output_prefix: str, perform_plink_qc: bool=True) -> None:
     validate_input_files(input_plink_prefix)
@@ -170,7 +170,7 @@ def run_complete_gwas_pipeline(input_plink_prefix: str, phenotype_file: str, out
         clean_geno_prefix = f'{output_prefix}_clean_geno'
         plink_quality_control(input_plink_prefix, clean_geno_prefix)
     else:
-        logger.info('Skipping PLINK QC in GWAS step based on upstream configuration')
+        logger.debug('Skipping PLINK QC in GWAS step based on upstream configuration')
         clean_geno_prefix = input_plink_prefix
     pca_prefix = f'{output_prefix}_geno_pca'
     calculate_pca(clean_geno_prefix, pca_prefix)
@@ -187,4 +187,4 @@ def run_complete_gwas_pipeline(input_plink_prefix: str, phenotype_file: str, out
     extract_pca_covariates(filtered_pca_file, cov_file)
     kinship_file = calculate_kinship_matrix(filtered_geno_prefix, output_prefix)
     run_gemma_gwas(filtered_geno_prefix, kinship_file, cov_file, output_prefix)
-    logger.info('GWAS pipeline completed')
+    logger.debug('GWAS pipeline completed')