scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/str/_parse.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-16 17:11:15 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/str/_parse.py
-
-THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/str/_parse.py"
+# Timestamp: "2025-07-16 10:14:44 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/str/_parse.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
 
 import re
 from typing import Dict, Union
@@ -12,16 +15,16 @@ from ..dict._DotDict import DotDict as _DotDict
 
 
 def parse(
-    input_str_or_pattern: str, pattern_or_input_str: str
+    string_or_fstring: str, fstring_or_string: str
 ) -> Union[Dict[str, Union[str, int]], str]:
     """
     Bidirectional parser that attempts parsing in both directions.
 
     Parameters
     ----------
-    input_str_or_pattern : str
+    string_or_fstring : str
         Either the input string to parse or the pattern
-    pattern_or_input_str : str
+    fstring_or_string : str
         Either the pattern to match against or the input string
 
     Returns
@@ -45,14 +48,14 @@ def parse(
     {'id': '23_002'}
     """
     # try:
-    #     parsed = _parse(input_str_or_pattern, pattern_or_input_str)
+    #     parsed = _parse(string_or_fstring, fstring_or_string)
     #     if parsed:
     #         return parsed
     # except Exception as e:
     #     print(e)
 
     # try:
-    #     parsed = _parse(pattern_or_input_str, input_str_or_pattern)
+    #     parsed = _parse(fstring_or_string, string_or_fstring)
     #     if parsed:
     #         return parsed
     # except Exception as e:
@@ -61,7 +64,7 @@ def parse(
 
     # Try first direction
     try:
-        result = _parse(input_str_or_pattern, pattern_or_input_str)
+        result = _parse(string_or_fstring, fstring_or_string)
         if result:
             return result
     except ValueError as e:
@@ -70,14 +73,16 @@ def parse(
 
     # Try reverse direction
     try:
-        result = _parse(pattern_or_input_str, input_str_or_pattern)
+        result = _parse(fstring_or_string, string_or_fstring)
         if result:
             return result
     except ValueError as e:
         errors.append(str(e))
         # logging.warning(f"Second attempt failed: {e}")
 
-    raise ValueError(f"Parsing failed in both directions: {' | '.join(errors)}")
+    raise ValueError(
+        f"Parsing failed in both directions: {' | '.join(errors)}"
+    )
 
 
 def _parse(string: str, expression: str) -> Dict[str, Union[str, int]]:
@@ -101,43 +106,47 @@ def _parse(string: str, expression: str) -> Dict[str, Union[str, int]]:
     ValueError
         If the string format does not match the given expression
         If duplicate placeholders have inconsistent values
+    """
+    # Clean up inputs
+    string = string.replace("/./", "/")
+    expression = expression.strip()
+    if expression.startswith('f"') and expression.endswith('"'):
+        expression = expression[2:-1]
+    elif expression.startswith('"') and expression.endswith('"'):
+        expression = expression[1:-1]
+    elif expression.startswith("'") and expression.endswith("'"):
+        expression = expression[1:-1]
 
-    Example
-    -------
-    >>> string = "./data/mat_tmp/Patient_23_002/Data_2010_07_31/Hour_12/UTC_12_02_00.mat"
-    >>> expression = "./data/mat_tmp/Patient_{patient_id}/Data_{YYYY}_{MM}_{DD}/Hour_{HH}/UTC_{HH}_{mm}_00.mat"
-    >>> parse_str(string, expression)
-    # {'patient_id': '23_002', 'YYYY': 2010, 'MM': 7, 'DD': 31, 'HH': 12, 'mm': 2}
+    # Remove format specifiers from placeholders
+    expression_clean = re.sub(r"{(\w+):[^}]+}", r"{\1}", expression)
 
-    # Inconsistent version
-    >>> string = "./data/mat_tmp/Patient_23_002/Data_2010_07_31/Hour_12/UTC_99_02_00.mat"
-    >>> expression = "./data/mat_tmp/Patient_{patient_id}/Data_{YYYY}_{MM}_{DD}/Hour_{HH}/UTC_{HH}_{mm}_00.mat"
-    >>> parse_str(string, expression)
-    # ValueError: Inconsistent values for placeholder 'HH'
-    """
+    # Extract placeholder names
+    placeholders = re.findall(r"{(\w+)}", expression_clean)
 
-    # Formatting
-    string = string.replace("/./", "/")
-    expression = expression.replace('f"', "").replace('"', "")
+    # Create regex pattern
+    pattern = re.sub(r"{(\w+)}", r"([^/]+)", expression_clean)
 
-    placeholders = re.findall(r"{(\w+)}", expression)
-    pattern = re.sub(r"{(\w+)}", "([^/]+)", expression)
     match = re.match(pattern, string)
 
     if not match:
         raise ValueError(
             f"String format does not match expression: {string} vs {expression}"
         )
-        # logging.warning(f"String format does not match the given expression. \nString input: {string}\nExpression: {expression}")
-        # return {}
 
     groups = match.groups()
     result = {}
 
     for placeholder, value in zip(placeholders, groups):
         if placeholder in result and result[placeholder] != value:
-            raise ValueError(f"Inconsistent values for placeholder '{placeholder}'")
-        result[placeholder] = value
+            raise ValueError(
+                f"Inconsistent values for placeholder '{placeholder}'"
+            )
+
+        # Try to convert to int if it looks like a number
+        if value.lstrip("-").isdigit():
+            result[placeholder] = int(value)
+        else:
+            result[placeholder] = value
 
     return _DotDict(result)
 
@@ -145,14 +154,13 @@ def _parse(string: str, expression: str) -> Dict[str, Union[str, int]]:
 if __name__ == "__main__":
     string = "./data/mat_tmp/Patient_23_002/Data_2010_07_31/Hour_12/UTC_12_02_00.mat"
     expression = "./data/mat_tmp/Patient_{patient_id}/Data_{YYYY}_{MM}_{DD}/Hour_{HH}/UTC_{HH}_{mm}_00.mat"
-    results = parse_str(string, expression)
+    results = parse(string, expression)
     print(results)
 
     # Inconsistent version
     string = "./data/mat_tmp/Patient_23_002/Data_2010_07_31/Hour_12/UTC_99_99_00.mat"
     expression = "./data/mat_tmp/Patient_{patient_id}/Data_{YYYY}_{MM}_{DD}/Hour_{HH}/UTC_{HH}_{mm}_00.mat"
-    results = parse_str(string, expression)  # this should raise error
+    results = parse(string, expression)  # this should raise error
     print(results)
 
-
 # EOF

scitex/str/_printc.py

@@ -4,9 +4,7 @@
 # File: /ssh:sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/str/_printc.py
 # ----------------------------------------
 import os
-__FILE__ = (
-    "./src/scitex/str/_printc.py"
-)
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 # Time-stamp: "2024-11-24 17:01:23 (ywatanabe)"

scitex/template/__init__.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/template/__init__.py
+
+"""
+Template management for SciTeX projects.
+"""
+
+from .create_research import create_research, TEMPLATE_REPO_URL as RESEARCH_URL
+from .create_pip_project import create_pip_project, TEMPLATE_REPO_URL as PIP_PROJECT_URL
+from .create_singularity import create_singularity, TEMPLATE_REPO_URL as SINGULARITY_URL
+
+
+def get_available_templates_info():
+    """
+    Get information about all available SciTeX project templates.
+
+    Returns
+    -------
+    list[dict]
+        List of template information dictionaries, each containing:
+        - id: Template identifier (used in code)
+        - name: Human-readable template name
+        - description: Template description
+        - github_url: GitHub repository URL
+        - use_case: When to use this template
+
+    Example
+    -------
+    >>> from scitex.template import get_available_templates_info
+    >>> templates = get_available_templates_info()
+    >>> for template in templates:
+    ...     print(f"{template['name']}: {template['description']}")
+    """
+    return [
+        {
+            "id": "research",
+            "name": "Research Project",
+            "description": "Full scientific workflow structure for research projects",
+            "github_url": RESEARCH_URL,
+            "use_case": "Scientific research with data analysis, experiments, and paper writing",
+            "features": [
+                "scripts/ - Analysis and preprocessing scripts",
+                "data/ - Raw and processed data management",
+                "docs/ - Manuscripts, notes, and references",
+                "results/ - Analysis outputs and reports",
+                "config/ - Project configuration files",
+            ],
+        },
+        {
+            "id": "pip_project",
+            "name": "Python Package",
+            "description": "Pip-installable Python package template",
+            "github_url": PIP_PROJECT_URL,
+            "use_case": "Creating distributable Python packages for PyPI",
+            "features": [
+                "src/ - Package source code",
+                "tests/ - Unit and integration tests",
+                "docs/ - Sphinx documentation",
+                "setup.py - Package configuration",
+                "CI/CD - GitHub Actions workflows",
+            ],
+        },
+        {
+            "id": "singularity",
+            "name": "Singularity Container",
+            "description": "Container-based project with Singularity",
+            "github_url": SINGULARITY_URL,
+            "use_case": "Reproducible computational environments with containers",
+            "features": [
+                "Singularity definition files",
+                "Container build scripts",
+                "Environment specifications",
+                "Deployment configuration",
+            ],
+        },
+    ]
+
+
+__all__ = [
+    "create_research",
+    "create_pip_project",
+    "create_singularity",
+    "get_available_templates_info",
+]
+
+# EOF

scitex/template/_create_project.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/template/_create_project.py
+
+"""
+Base functionality for creating projects from template repositories.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from scitex.logging import getLogger
+
+logger = getLogger(__name__)
+
+
+def _copy_tree_skip_broken_symlinks(src: Path, dst: Path) -> None:
+    """
+    Copy directory tree, skipping broken symlinks.
+
+    Parameters
+    ----------
+    src : Path
+        Source directory
+    dst : Path
+        Destination directory
+    """
+    dst.mkdir(parents=True, exist_ok=True)
+
+    for item in src.iterdir():
+        src_item = src / item.name
+        dst_item = dst / item.name
+
+        # Check if it's a symlink and if it's broken
+        if src_item.is_symlink():
+            try:
+                # Try to resolve the symlink
+                src_item.resolve(strict=True)
+                # If successful, copy it
+                if src_item.is_dir():
+                    _copy_tree_skip_broken_symlinks(src_item, dst_item)
+                else:
+                    shutil.copy2(src_item, dst_item)
+            except (OSError, FileNotFoundError):
+                # Broken symlink - skip it
+                logger.warning(f"Skipping broken symlink: {src_item}")
+                continue
+        elif src_item.is_dir():
+            _copy_tree_skip_broken_symlinks(src_item, dst_item)
+        else:
+            shutil.copy2(src_item, dst_item)
+
+
+def _rename_template_package(target_path: Path, project_name: str, template_package_name: str = "pip_project_template") -> None:
+    """
+    Rename template package directories and update all references.
+
+    Parameters
+    ----------
+    target_path : Path
+        Path to the project directory
+    project_name : str
+        New name for the project/package
+    template_package_name : str
+        Original template package name to be replaced
+    """
+    # Rename directories
+    src_template_dir = target_path / "src" / template_package_name
+    tests_template_dir = target_path / "tests" / template_package_name
+
+    if src_template_dir.exists():
+        src_new_dir = target_path / "src" / project_name
+        logger.info(f"Renaming {src_template_dir} to {src_new_dir}")
+        src_template_dir.rename(src_new_dir)
+
+    if tests_template_dir.exists():
+        tests_new_dir = target_path / "tests" / project_name
+        logger.info(f"Renaming {tests_template_dir} to {tests_new_dir}")
+        tests_template_dir.rename(tests_new_dir)
+
+    # Update file contents
+    logger.info(f"Updating references from {template_package_name} to {project_name}")
+
+    # Files that typically contain package name references
+    files_to_update = [
+        target_path / "pyproject.toml",
+        target_path / "README.md",
+        target_path / "Makefile",
+    ]
+
+    # Also update all Python files
+    for py_file in target_path.rglob("*.py"):
+        files_to_update.append(py_file)
+
+    for file_path in files_to_update:
+        if not file_path.exists() or file_path.is_dir():
+            continue
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Replace template package name with project name
+            updated_content = content.replace(template_package_name, project_name)
+
+            # Only write if content changed
+            if updated_content != content:
+                with open(file_path, "w", encoding="utf-8") as f:
+                    f.write(updated_content)
+                logger.info(f"Updated references in {file_path.relative_to(target_path)}")
+
+        except Exception as e:
+            logger.warning(f"Failed to update {file_path}: {str(e)}")
+
+
+def create_project(
+    project_name: str,
+    target_dir: Optional[str],
+    template_url: str,
+    template_name: str,
+) -> bool:
+    """
+    Generic function to create a project from a template repository.
+
+    Parameters
+    ----------
+    project_name : str
+        Name of the new project
+    target_dir : str, optional
+        Directory where the project will be created. If None, uses current directory.
+    template_url : str
+        Git repository URL of the template
+    template_name : str
+        Name of the template (for logging purposes)
+
+    Returns
+    -------
+    bool
+        True if successful, False otherwise
+
+    Raises
+    ------
+    FileExistsError
+        If the target project directory already exists
+    """
+    try:
+        # Determine target directory
+        if target_dir is None:
+            target_dir = os.getcwd()
+
+        target_path = Path(target_dir) / project_name
+
+        # Check if target directory already exists
+        if target_path.exists():
+            logger.error(f"Directory already exists: {target_path}")
+            logger.error("Please choose a different project name or remove the existing directory")
+            return False
+
+        logger.info(f"Creating new project from {template_name}: {project_name}")
+        logger.info(f"Target directory: {target_path}")
+
+        # Create temporary directory for cloning
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir) / "template"
+
+            logger.info(f"Cloning template from {template_url}")
+
+            # Clone the template repository
+            result = subprocess.run(
+                ["git", "clone", template_url, str(temp_path)],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode != 0:
+                logger.error(f"Failed to clone template: {result.stderr}")
+                return False
+
+            logger.info("Template cloned successfully")
+
+            # Remove .git directory from template to avoid conflicts
+            git_dir = temp_path / ".git"
+            if git_dir.exists():
+                shutil.rmtree(git_dir)
+                logger.info("Removed template .git directory")
+
+            # Copy template to target location
+            logger.info(f"Copying template to {target_path}")
+            _copy_tree_skip_broken_symlinks(temp_path, target_path)
+
+            logger.info("Template copied successfully")
+
+        # Rename template package and update references
+        logger.info("Customizing template for project")
+        _rename_template_package(target_path, project_name)
+
+        # Initialize new git repository
+        logger.info("Initializing new git repository")
+        result = subprocess.run(
+            ["git", "init"],
+            cwd=str(target_path),
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            logger.warning(f"Failed to initialize git repository: {result.stderr}")
+        else:
+            logger.info("Git repository initialized successfully")
+
+        # Create initial commit
+        logger.info("Creating initial commit")
+        subprocess.run(
+            ["git", "add", "."],
+            cwd=str(target_path),
+            capture_output=True,
+        )
+        subprocess.run(
+            ["git", "commit", "-m", f"Initial commit from {template_name}"],
+            cwd=str(target_path),
+            capture_output=True,
+        )
+
+        # Rename branch to main
+        logger.info("Renaming branch to main")
+        result = subprocess.run(
+            ["git", "branch", "-M", "main"],
+            cwd=str(target_path),
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            logger.warning(f"Failed to rename branch to main: {result.stderr}")
+        else:
+            logger.info("Branch renamed to main successfully")
+
+        # Create and switch to develop branch
+        logger.info("Creating develop branch")
+        result = subprocess.run(
+            ["git", "checkout", "-b", "develop"],
+            cwd=str(target_path),
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            logger.warning(f"Failed to create develop branch: {result.stderr}")
+        else:
+            logger.info("Switched to develop branch successfully")
+
+        logger.info(f"Successfully created project: {project_name}")
+        logger.info(f"Project location: {target_path}")
+        logger.info(f"Current branch: develop")
+        logger.info(f"Next steps:")
+        logger.info(f"  cd {target_path}")
+
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to create project: {str(e)}")
+        return False
+
+# EOF

scitex/template/create_pip_project.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/template/create_pip_project.py
+
+"""
+Create a new pip project from the pip-project-template.
+"""
+
+import sys
+from typing import Optional
+
+from ._create_project import create_project
+
+TEMPLATE_REPO_URL = "https://github.com/ywatanabe1989/pip-project-template.git"
+
+
+def create_pip_project(project_name: str, target_dir: Optional[str] = None) -> bool:
+    """
+    Create a new pip project from the template repository.
+
+    Parameters
+    ----------
+    project_name : str
+        Name of the new pip project
+    target_dir : str, optional
+        Directory where the project will be created. If None, uses current directory.
+
+    Returns
+    -------
+    bool
+        True if successful, False otherwise
+
+    Example
+    -------
+    >>> from scitex.template import create_pip_project
+    >>> create_pip_project("my_pip_project")
+    """
+    return create_project(
+        project_name,
+        target_dir,
+        TEMPLATE_REPO_URL,
+        "pip-project-template",
+    )
+
+
+def main(args: list = None) -> None:
+    """
+    Command-line interface for create_pip_project.
+
+    Parameters
+    ----------
+    args : list, optional
+        Command-line arguments. If None, uses sys.argv[1:]
+    """
+    if args is None:
+        args = sys.argv[1:]
+
+    if len(args) < 1:
+        print("Usage: python -m scitex create_pip_project <project-name> [target-dir]")
+        print("")
+        print("Arguments:")
+        print("  project-name  Name of the new pip project")
+        print("  target-dir    Optional: Directory where project will be created (default: current directory)")
+        print("")
+        print("Example:")
+        print("  python -m scitex create_pip_project my_pip_project")
+        print("  python -m scitex create_pip_project my_project ~/projects")
+        sys.exit(1)
+
+    project_name = args[0]
+    target_dir = args[1] if len(args) > 1 else None
+
+    success = create_pip_project(project_name, target_dir)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
+
+# EOF

scitex/template/create_research.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/template/create_research.py
+
+"""
+Create a new research project from the scitex_template_research template.
+"""
+
+import sys
+from typing import Optional
+
+from ._create_project import create_project
+
+TEMPLATE_REPO_URL = "https://github.com/ywatanabe1989/scitex_template_research.git"
+
+
+def create_research(project_name: str, target_dir: Optional[str] = None) -> bool:
+    """
+    Create a new research project from the template repository.
+
+    Parameters
+    ----------
+    project_name : str
+        Name of the new research project
+    target_dir : str, optional
+        Directory where the project will be created. If None, uses current directory.
+
+    Returns
+    -------
+    bool
+        True if successful, False otherwise
+
+    Example
+    -------
+    >>> from scitex.template import create_research
+    >>> create_research("my_research_project")
+    """
+    return create_project(
+        project_name,
+        target_dir,
+        TEMPLATE_REPO_URL,
+        "scitex_template_research",
+    )
+
+
+def main(args: list = None) -> None:
+    """
+    Command-line interface for create_research.
+
+    Parameters
+    ----------
+    args : list, optional
+        Command-line arguments. If None, uses sys.argv[1:]
+    """
+    if args is None:
+        args = sys.argv[1:]
+
+    if len(args) < 1:
+        print("Usage: python -m scitex create_research_project <project-name> [target-dir]")
+        print("")
+        print("Arguments:")
+        print("  project-name  Name of the new research project")
+        print("  target-dir    Optional: Directory where project will be created (default: current directory)")
+        print("")
+        print("Example:")
+        print("  python -m scitex create_research_project my_research_project")
+        print("  python -m scitex create_research_project my_project ~/projects")
+        sys.exit(1)
+
+    project_name = args[0]
+    target_dir = args[1] if len(args) > 1 else None
+
+    success = create_research(project_name, target_dir)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
+
+# EOF