scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/utils/_scitex_config.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# SciTeX Ecosystem Configuration Manager
+
+"""
+Unified configuration system for the complete SciTeX ecosystem:
+SciTeX + SciTeX-Code + SciTeX-Paper + SigMacro + Emacs-Claude-Code integration
+"""
+
+import os
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional
+import json
+
+
+class SciTeXConfig:
+    """Central configuration manager for the SciTeX ecosystem"""
+    
+    def __init__(self, config_path: Optional[str] = None):
+        """Initialize SciTeX configuration
+        
+        Parameters
+        ----------
+        config_path : str, optional
+            Path to configuration file. Defaults to ~/.scitex/config.yaml
+        """
+        self.config_path = config_path or os.path.expanduser("~/.scitex/config.yaml")
+        self.config = self._load_config()
+        
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from file or create default"""
+        if os.path.exists(self.config_path):
+            with open(self.config_path, 'r') as f:
+                return yaml.safe_load(f) or {}
+        else:
+            return self._create_default_config()
+    
+    def _create_default_config(self) -> Dict[str, Any]:
+        """Create default SciTeX ecosystem configuration"""
+        default_config = {
+            'scitex_ecosystem': {
+                'version': '1.0.0',
+                'core_engine': 'claude_code',
+                'emacs_integration': True,
+                'auto_workflow': True
+            },
+            
+            'paths': {
+                'scitex_paper': '~/proj/SciTeX-Paper/',
+                'scitex_code': '~/proj/SciTeX-Code/',
+                'sigmacro': '~/proj/SigMacro/',
+                'emacs_claude': '~/proj/emacs-claude-code/',
+                'scitex_data': '~/data/',
+                'output': '~/output/'
+            },
+            
+            'scitex': {
+                'auto_metadata': True,
+                'yaml_export': True,
+                'csv_export': True,
+                'tracking_enabled': True,
+                'default_journal': 'nature'
+            },
+            
+            'ai_integration': {
+                'claude_code_enabled': True,
+                'auto_code_generation': True,
+                'auto_manuscript_writing': True,
+                'ai_assisted_analysis': True,
+                'emacs_claude_integration': True
+            },
+            
+            'publication': {
+                'default_journal': 'nature',
+                'auto_formatting': True,
+                'latex_compilation': True,
+                'submission_package': True,
+                'reproducibility_level': 'full'
+            },
+            
+            'workflow': {
+                'auto_save_metadata': True,
+                'auto_export_yaml': True,
+                'auto_generate_methods': True,
+                'auto_create_figures': True,
+                'ai_quality_check': True
+            }
+        }
+        
+        # Create config directory and save
+        os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
+        self.save_config(default_config)
+        return default_config
+    
+    def save_config(self, config: Dict[str, Any] = None):
+        """Save configuration to file"""
+        config_to_save = config or self.config
+        with open(self.config_path, 'w') as f:
+            yaml.dump(config_to_save, f, default_flow_style=False, sort_keys=False, indent=2)
+    
+    def get_scitex_paths(self) -> Dict[str, str]:
+        """Get expanded SciTeX ecosystem paths"""
+        paths = {}
+        for key, path in self.config.get('paths', {}).items():
+            paths[key] = os.path.expanduser(path)
+        return paths
+    
+    def setup_scitex_directories(self):
+        """Create SciTeX ecosystem directory structure"""
+        paths = self.get_scitex_paths()
+        
+        # Create main directories
+        for path_name, path in paths.items():
+            os.makedirs(path, exist_ok=True)
+            
+        # Create SciTeX-Paper subdirectories
+        scitex_paper = paths.get('scitex_paper')
+        if scitex_paper:
+            subdirs = ['figures', 'data', 'metadata', 'code', 'sections', 'manuscripts']
+            for subdir in subdirs:
+                os.makedirs(os.path.join(scitex_paper, subdir), exist_ok=True)
+    
+    def get_ai_settings(self) -> Dict[str, Any]:
+        """Get AI integration settings"""
+        return self.config.get('ai_integration', {})
+    
+    def get_publication_settings(self) -> Dict[str, Any]:
+        """Get publication workflow settings"""
+        return self.config.get('publication', {})
+    
+    def is_emacs_claude_enabled(self) -> bool:
+        """Check if Emacs-Claude integration is enabled"""
+        return self.config.get('ai_integration', {}).get('emacs_claude_integration', False)
+    
+    def get_default_journal(self) -> str:
+        """Get default target journal"""
+        return self.config.get('publication', {}).get('default_journal', 'nature')
+    
+    def enable_ai_workflow(self):
+        """Enable full AI-powered workflow"""
+        self.config['ai_integration']['claude_code_enabled'] = True
+        self.config['ai_integration']['auto_code_generation'] = True
+        self.config['ai_integration']['auto_manuscript_writing'] = True
+        self.config['workflow']['ai_quality_check'] = True
+        self.save_config()
+    
+    def create_project_config(self, project_name: str, project_path: str):
+        """Create project-specific configuration"""
+        project_config = {
+            'project': {
+                'name': project_name,
+                'path': project_path,
+                'created': str(pd.Timestamp.now()),
+                'scitex_version': '1.0.0'
+            },
+            'inherit_from': self.config_path,
+            'overrides': {
+                'paths': {
+                    'output': os.path.join(project_path, 'output'),
+                    'data': os.path.join(project_path, 'data'),
+                    'figures': os.path.join(project_path, 'figures')
+                }
+            }
+        }
+        
+        project_config_path = os.path.join(project_path, '.scitex_project.yaml')
+        with open(project_config_path, 'w') as f:
+            yaml.dump(project_config, f, default_flow_style=False, indent=2)
+        
+        return project_config_path
+
+
+# Global configuration instance
+_scitex_config = None
+
+def get_scitex_config() -> SciTeXConfig:
+    """Get global SciTeX configuration instance"""
+    global _scitex_config
+    if _scitex_config is None:
+        _scitex_config = SciTeXConfig()
+    return _scitex_config
+
+
+def configure_scitex_ecosystem():
+    """Configure the complete SciTeX ecosystem"""
+    config = get_scitex_config()
+    
+    print("🚀 Configuring SciTeX Ecosystem...")
+    print("="*50)
+    
+    # Setup directories
+    config.setup_scitex_directories()
+    paths = config.get_scitex_paths()
+    
+    print("📁 Directory Structure:")
+    for name, path in paths.items():
+        status = "✅" if os.path.exists(path) else "❌"
+        print(f"  {status} {name}: {path}")
+    
+    # Check AI integration
+    print("\n🤖 AI Integration:")
+    ai_settings = config.get_ai_settings()
+    for setting, enabled in ai_settings.items():
+        status = "✅" if enabled else "❌"
+        print(f"  {status} {setting}")
+    
+    # Check Emacs-Claude integration
+    emacs_claude_path = paths.get('emacs_claude')
+    if emacs_claude_path and os.path.exists(emacs_claude_path):
+        print(f"\n💻 Emacs-Claude Integration: ✅ {emacs_claude_path}")
+    else:
+        print(f"\n💻 Emacs-Claude Integration: ❌ Not found")
+    
+    print(f"\n📋 Configuration saved: {config.config_path}")
+    print("\n🎯 SciTeX Ecosystem Ready!")
+    
+    return config
+
+
+if __name__ == "__main__":
+    # Setup the complete ecosystem
+    configure_scitex_ecosystem()

scitex/reproduce/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""Scitex reproduce module."""
+
+from ._fix_seeds import fix_seeds
+from ._gen_ID import gen_ID, gen_id
+from ._gen_timestamp import gen_timestamp, timestamp
+
+__all__ = [
+    "fix_seeds",
+    "gen_ID",
+    "gen_id",
+    "gen_timestamp",
+    "timestamp",
+]

scitex/reproduce/_fix_seeds.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 14:28:12 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/reproduce/_fix_seeds.py
+
+
+def fix_seeds(
+    os=None, random=None, np=None, torch=None, tf=None, seed=42, verbose=True
+):
+    os_str = "os" if os is not None else ""
+    random_str = "random" if random is not None else ""
+    np_str = "np" if np is not None else ""
+    torch_str = "torch" if torch is not None else ""
+    tf_str = "tf" if tf is not None else ""
+
+    # https://github.com/lucidrains/vit-pytorch/blob/main/examples/cats_and_dogs.ipynb
+    if os is not None:
+        import os
+
+        os.environ["PYTHONHASHSEED"] = str(seed)
+
+    if random is not None:
+        random.seed(seed)
+
+    if np is not None:
+        np.random.seed(seed)
+
+    if torch is not None:
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        # torch.use_deterministic_algorithms(True)
+
+    if tf is not None:
+        tf.random.set_seed(seed)
+
+    if verbose:
+        print(f"\n{'-'*40}\n")
+        print(f"Random seeds of the following packages have been fixed as {seed}")
+        print(os_str, random_str, np_str, torch_str, tf_str)
+        print(f"\n{'-'*40}\n")
+
+
+# EOF

scitex/reproduce/_gen_ID.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 17:53:38 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/reproduce/_gen_ID.py
+
+import random as _random
+import string as _string
+from datetime import datetime as _datetime
+
+
+def gen_id(time_format="%YY-%mM-%dD-%Hh%Mm%Ss", N=8):
+    """Generate a unique identifier with timestamp and random characters.
+
+    Creates a unique ID by combining a formatted timestamp with random
+    alphanumeric characters. Useful for creating unique experiment IDs,
+    run identifiers, or temporary file names.
+
+    Parameters
+    ----------
+    time_format : str, optional
+        Format string for timestamp portion. Default is "%YY-%mM-%dD-%Hh%Mm%Ss"
+        which produces "2025Y-05M-31D-12h30m45s" format.
+    N : int, optional
+        Number of random characters to append. Default is 8.
+
+    Returns
+    -------
+    str
+        Unique identifier in format "{timestamp}_{random_chars}"
+
+    Examples
+    --------
+    >>> id1 = gen_id()
+    >>> print(id1)
+    '2025Y-05M-31D-12h30m45s_a3Bc9xY2'
+
+    >>> id2 = gen_id(time_format="%Y%m%d", N=4)
+    >>> print(id2)
+    '20250531_xY9a'
+
+    >>> # For experiment tracking
+    >>> exp_id = gen_id()
+    >>> save_path = f"results/experiment_{exp_id}.pkl"
+    """
+    now_str = _datetime.now().strftime(time_format)
+    rand_str = "".join(
+        [_random.choice(_string.ascii_letters + _string.digits) for i in range(N)]
+    )
+    return now_str + "_" + rand_str
+
+
+# Backward compatibility
+gen_ID = gen_id  # Deprecated: use gen_id instead
+
+# EOF

scitex/reproduce/_gen_timestamp.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 17:44:32 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/reproduce/_gen_timestamp.py
+
+from datetime import datetime as _datetime
+
+
+def gen_timestamp():
+    """Generate a timestamp string for file naming.
+
+    Returns a timestamp in the format YYYY-MMDD-HHMM, suitable for
+    creating unique filenames or version identifiers.
+
+    Returns
+    -------
+    str
+        Timestamp string in format "YYYY-MMDD-HHMM"
+
+    Examples
+    --------
+    >>> timestamp = gen_timestamp()
+    >>> print(timestamp)
+    '2025-0531-1230'
+
+    >>> filename = f"experiment_{gen_timestamp()}.csv"
+    >>> print(filename)
+    'experiment_2025-0531-1230.csv'
+    """
+    return _datetime.now().strftime("%Y-%m%d-%H%M")
+
+
+timestamp = gen_timestamp
+
+# EOF

scitex/res/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+"""Scitex res - resource module (currently empty)."""
+
+# This module is currently empty but preserved for compatibility
+__all__ = []

scitex/resource/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Scitex resource module."""
+
+from ._get_processor_usages import get_processor_usages
+from ._get_specs import get_specs
+from ._log_processor_usages import log_processor_usages, main
+
+__all__ = [
+    "get_processor_usages",
+    "get_specs",
+    "log_processor_usages",
+    "main",
+]

scitex/resource/_get_processor_usages.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-04 16:12:50 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/resource/_get_processor_usages.py
+
+"""
+Functionality:
+    * Monitors and records system resource utilization (CPU, RAM, GPU, VRAM)
+Input:
+    * None (uses system calls and psutil library)
+Output:
+    * DataFrame containing resource usage statistics
+Prerequisites:
+    * NVIDIA GPU with nvidia-smi installed
+    * psutil package
+"""
+
+import os
+import subprocess
+import sys
+from datetime import datetime
+from typing import Optional, Tuple
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import psutil
+
+
+def get_processor_usages() -> pd.DataFrame:
+    """Gets current system resource usage statistics.
+
+    Returns
+    -------
+    pd.DataFrame
+        Resource usage data with columns:
+        - Timestamp: Timestamp
+        - CPU [%]: CPU utilization
+        - RAM [GiB]: RAM usage
+        - GPU [%]: GPU utilization
+        - VRAM [GiB]: VRAM usage
+
+    Example
+    -------
+    >>> df = get_proccessor_usages()
+    >>> print(df)
+                 Timestamp  CPU [%]  RAM [GiB]  GPU [%]  VRAM [GiB]
+    0  2024-11-04 10:30:15    25.3      8.2     65.0        4.5
+    """
+    try:
+        cpu_perc, ram_gb = _get_cpu_usage()
+        gpu_perc, vram_gb = _get_gpu_usage()
+
+        sr = pd.Series(
+            {
+                "Timestamp": datetime.now(),
+                "CPU [%]": cpu_perc,
+                "RAM [GiB]": ram_gb,
+                "GPU [%]": gpu_perc,
+                "VRAM [GiB]": vram_gb,
+            }
+        )
+
+        return pd.DataFrame(sr).round(1).T
+    except Exception as err:
+        raise RuntimeError(f"Failed to get resource usage: {err}")
+
+
+def _get_cpu_usage(
+    process: Optional[int] = os.getpid(), n_round: int = 1
+) -> Tuple[float, float]:
+    """Gets CPU and RAM usage statistics.
+
+    Parameters
+    ----------
+    process : int, optional
+        Process ID to monitor
+    n_round : int, optional
+        Number of decimal places to round to
+
+    Returns
+    -------
+    Tuple[float, float]
+        CPU usage percentage and RAM usage in GiB
+    """
+    try:
+        cpu_usage_perc = psutil.cpu_percent()
+        ram_usage_gb = (
+            psutil.virtual_memory().percent
+            / 100
+            * psutil.virtual_memory().total
+            / (1024**3)
+        )
+        return round(cpu_usage_perc, n_round), round(ram_usage_gb, n_round)
+    except Exception as err:
+        raise RuntimeError(f"Failed to get CPU/RAM usage: {err}")
+
+
+def _get_gpu_usage(n_round: int = 1) -> Tuple[float, float]:
+    """Gets GPU and VRAM usage statistics.
+
+    Parameters
+    ----------
+    n_round : int, optional
+        Number of decimal places to round to
+
+    Returns
+    -------
+    Tuple[float, float]
+        GPU usage percentage and VRAM usage in GiB
+    """
+    try:
+        result = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-gpu=utilization.gpu,memory.used",
+                "--format=csv,nounits,noheader",
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        gpu_usage_perc, vram_usage_mib = result.stdout.strip().split(",")
+        vram_usage_gb = float(vram_usage_mib) / 1024
+        return round(float(gpu_usage_perc), n_round), round(vram_usage_gb, n_round)
+    except:
+        return 0.0, 0.0
+    # except subprocess.CalledProcessError as err:
+    #     raise RuntimeError(f"Failed to execute nvidia-smi: {err}")
+    # except Exception as err:
+    #     raise RuntimeError(f"Failed to get GPU/VRAM usage: {err}")
+
+
+# def _get_gpu_usage(n_round: int = 1) -> Tuple[float, float]:
+#     """Gets GPU and VRAM usage statistics.
+
+#     Parameters
+#     ----------
+#     n_round : int, optional
+#         Number of decimal places to round to
+
+#     Returns
+#     -------
+#     Tuple[float, float]
+#         GPU usage percentage and VRAM usage in GiB
+#     """
+#     try:
+#         result = subprocess.run(
+#             [
+#                 "nvidia-smi",
+#                 "--query-gpu=utilization.gpu,memory.used",
+#                 "--format=csv,nounits,noheader",
+#             ],
+#             capture_output=True,
+#             text=True,
+#             check=True,
+#         )
+#         gpu_usage_perc, vram_usage_mib = result.stdout.strip().split(",")
+#         vram_usage_gb = float(vram_usage_mib) / 1024
+#         return round(float(gpu_usage_perc), n_round), round(vram_usage_gb, n_round)
+#     except Exception as e:
+#         print(e)
+#         return 0.0, 0.0  # Return zeros when nvidia-smi is not available
+
+
+if __name__ == "__main__":
+    import scitex
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+
+    usage = scitex.resource.get_processor_usages()
+    scitex.io.save(usage, "usage.csv")
+
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF
+
+# #!/usr/bin/env python3
+# # -*- coding: utf-8 -*-
+# # Time-stamp: "2024-11-04 10:27:35 (ywatanabe)"
+# # File: ./scitex_repo/src/scitex/resource/_get_processor_usages.py
+
+# """
+# This script does XYZ.
+# """
+
+# # Functions
+# import os
+# import subprocess
+# import sys
+# from datetime import datetime
+
+# import matplotlib.pyplot as plt
+# import scitex
+# import pandas as pd
+# import psutil
+
+
+# # Functions
+# def get_processor_usages():
+#     """
+#     Retrieves the current usage statistics for the CPU, RAM, GPU, and VRAM.
+
+#     This function fetches the current usage percentages for the CPU and GPU, as well as the current usage in GiB for RAM and VRAM.
+#     The data is then compiled into a pandas DataFrame with the current timestamp.
+
+#     Returns:
+#         pd.DataFrame: A pandas DataFrame containing the current usage statistics with the following columns:
+#                       - Time: The timestamp when the data was retrieved.
+#                       - CPU [%]: The CPU usage percentage.
+#                       - RAM [GiB]: The RAM usage in GiB.
+#                       - GPU [%]: The GPU usage percentage.
+#                       - VRAM [GiB]: The VRAM usage in GiB.
+#                       Each row in the DataFrame represents a single instance of data retrieval, rounded to 1 decimal place.
+
+#     Example:
+#         >>> usage_df = get_processor_usages()
+#         >>> print(usage_df)
+#     """
+#     cpu_perc, ram_gb = _get_cpu_usage()
+#     gpu_perc, vram_gb = _get_gpu_usage()
+
+#     sr = pd.Series(
+#         {
+#             "Time": datetime.now(),
+#             "CPU [%]": cpu_perc,
+#             "RAM [GiB]": ram_gb,
+#             "GPU [%]": gpu_perc,
+#             "VRAM [GiB]": vram_gb,
+#         }
+#     )
+
+#     df = pd.DataFrame(sr).round(1).T
+
+#     return df
+
+
+# def _get_cpu_usage(process=os.getpid(), n_round=1):
+#     cpu_usage_perc = psutil.cpu_percent()
+#     ram_usage_gb = (
+#         psutil.virtual_memory().percent
+#         / 100
+#         * psutil.virtual_memory().total
+#         / (1024**3)
+#     )
+#     return round(cpu_usage_perc, n_round), round(ram_usage_gb, n_round)
+
+
+# def _get_gpu_usage(n_round=1):
+#     result = subprocess.run(
+#         [
+#             "nvidia-smi",
+#             "--query-gpu=utilization.gpu,memory.used",
+#             "--format=csv,nounits,noheader",
+#         ],
+#         capture_output=True,
+#         text=True,
+#     )
+#     gpu_usage_perc, _vram_usage_mib = result.stdout.strip().split(",")
+#     vram_usage_gb = float(_vram_usage_mib) / 1024
+#     return round(float(gpu_usage_perc), n_round), round(
+#         float(vram_usage_gb), n_round
+#     )
+
+
+# # (YOUR AWESOME CODE)
+
+# if __name__ == "__main__":
+#     # Start
+#     CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(
+#         sys, plt, verbose=False
+#     )
+
+#     usage = scitex.resource.get_processor_usages()
+#     scitex.io.save(usage, "usage.csv")
+
+#     # Close
+#     scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+#
+
+# EOF