sparkkflow 0.1.0__tar.gz

sparkkflow-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: sparkkflow
+Version: 0.1.0
+Summary: ARPES workflow engine with SPR-KKR, OSCARpes and ML polarization calibration
+Author: Ridha Eddhib
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: pyyaml
+Requires-Dist: pandas
+Provides-Extra: ml
+Requires-Dist: torch; extra == "ml"
+Requires-Dist: scikit-learn; extra == "ml"
+Provides-Extra: oscarpes
+Requires-Dist: duckdb; extra == "oscarpes"
+Requires-Dist: pyarrow; extra == "oscarpes"
+Requires-Dist: fsspec; extra == "oscarpes"
+Requires-Dist: oscarpes; extra == "oscarpes"
+Provides-Extra: remote
+Requires-Dist: paramiko; extra == "remote"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+# Sparkkflow
+
+ARPES workflow engine with SPR-KKR, OSCARpes ingestion and ML polarization calibration.
+
+## Install
+
+```bash
+pip install -e .              # core
+pip install -e ".[ml]"        # + torch / scikit-learn
+pip install -e ".[oscarpes]"  # + OSCARpes ingestion
+pip install -e ".[dev]"       # + pytest / ruff / mypy
+```
+
+## CLI
+
+```bash
+sparkkflow doctor                                   # check tooling
+sparkkflow scan --energy-range 20 50 --dicho        # run an ARPES scan
+sparkkflow generate --energy-range 20 100 --fine-grid
+sparkkflow train --model-path pol.pth
+sparkkflow predict --model-path pol.pth --energy 30
+sparkkflow monitor --job-ids 12,34 --continuous
+```
+
+## Library
+
+```python
+from sparkkflow.config import manager
+from sparkkflow.scans import scans
+from sparkkflow.jobs import submitter
+from sparkkflow.ml import pipeline, train, predict
+from sparkkflow.monitor import watch, status
+
+cfg = manager("config.yaml").config
+runner = scans(scheduler_type=cfg.scheduler.default_type, ml_mode=False)
+runner.run(energy_range=(20, 50), dicho=True)
+```
+
+## Layout
+
+```
+sparkkflow/
+  __init__.py       # public API surface
+  cli.py            # `sparkkflow` console entry point
+  config.py         # YAML loader, env overrides, validation
+  log.py            # structured logging
+  jobs.py           # SLURM / SGE submitter (`submitter`, `slurm`, `sge`)
+  scans.py          # ARPES parameter scans (`scans`)
+  ml.py             # PyTorch pipeline + train / predict
+  monitor.py        # status polling and resubmission
+  plot.py           # dichroism plotting
+  trcdad*.py        # TR+CDAD utilities
+  calc_*.py         # SPR-KKR calculators
+  atom_*.py         # atomic-position scans
+config.yaml         # configuration template
+examples/           # runnable demos
+tests/              # pytest suite
+```
+
+## Naming conventions
+
+- All modules and public classes are **lowercase, snake_case, ASCII**.
+- No `+`, `-`, spaces, or version words like `enhanced` in filenames.
+- One short responsibility per module name (`config`, `jobs`, `ml`, `scans`).
+
+## Development
+
+```bash
+pytest -q
+ruff check sparkkflow tests
+mypy sparkkflow
+```

sparkkflow-0.1.0/README.md

@@ -0,0 +1,72 @@
+# Sparkkflow
+
+ARPES workflow engine with SPR-KKR, OSCARpes ingestion and ML polarization calibration.
+
+## Install
+
+```bash
+pip install -e .              # core
+pip install -e ".[ml]"        # + torch / scikit-learn
+pip install -e ".[oscarpes]"  # + OSCARpes ingestion
+pip install -e ".[dev]"       # + pytest / ruff / mypy
+```
+
+## CLI
+
+```bash
+sparkkflow doctor                                   # check tooling
+sparkkflow scan --energy-range 20 50 --dicho        # run an ARPES scan
+sparkkflow generate --energy-range 20 100 --fine-grid
+sparkkflow train --model-path pol.pth
+sparkkflow predict --model-path pol.pth --energy 30
+sparkkflow monitor --job-ids 12,34 --continuous
+```
+
+## Library
+
+```python
+from sparkkflow.config import manager
+from sparkkflow.scans import scans
+from sparkkflow.jobs import submitter
+from sparkkflow.ml import pipeline, train, predict
+from sparkkflow.monitor import watch, status
+
+cfg = manager("config.yaml").config
+runner = scans(scheduler_type=cfg.scheduler.default_type, ml_mode=False)
+runner.run(energy_range=(20, 50), dicho=True)
+```
+
+## Layout
+
+```
+sparkkflow/
+  __init__.py       # public API surface
+  cli.py            # `sparkkflow` console entry point
+  config.py         # YAML loader, env overrides, validation
+  log.py            # structured logging
+  jobs.py           # SLURM / SGE submitter (`submitter`, `slurm`, `sge`)
+  scans.py          # ARPES parameter scans (`scans`)
+  ml.py             # PyTorch pipeline + train / predict
+  monitor.py        # status polling and resubmission
+  plot.py           # dichroism plotting
+  trcdad*.py        # TR+CDAD utilities
+  calc_*.py         # SPR-KKR calculators
+  atom_*.py         # atomic-position scans
+config.yaml         # configuration template
+examples/           # runnable demos
+tests/              # pytest suite
+```
+
+## Naming conventions
+
+- All modules and public classes are **lowercase, snake_case, ASCII**.
+- No `+`, `-`, spaces, or version words like `enhanced` in filenames.
+- One short responsibility per module name (`config`, `jobs`, `ml`, `scans`).
+
+## Development
+
+```bash
+pytest -q
+ruff check sparkkflow tests
+mypy sparkkflow
+```

sparkkflow-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sparkkflow"
+version = "0.1.0"
+description = "ARPES workflow engine with SPR-KKR, OSCARpes and ML polarization calibration"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "Ridha Eddhib" }]
+license = { text = "MIT" }
+dependencies = [
+    "numpy",
+    "scipy",
+    "matplotlib",
+    "pyyaml",
+    "pandas",
+]
+
+[project.optional-dependencies]
+ml = ["torch", "scikit-learn"]
+oscarpes = ["duckdb", "pyarrow", "fsspec", "oscarpes"]
+remote = ["paramiko"]
+dev = ["pytest", "ruff", "mypy"]
+
+[project.scripts]
+sparkkflow = "sparkkflow.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["sparkkflow*"]
+exclude = ["tests*", "examples*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.9"
+ignore_missing_imports = true
+warn_unused_ignores = true

sparkkflow-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sparkkflow-0.1.0/sparkkflow/__init__.py

@@ -0,0 +1,6 @@
+"""Sparkkflow — ARPES workflow engine with SPR-KKR, OSCARpes and ML."""
+
+from . import config, jobs, log, ml, monitor, scans
+
+__all__ = ['config', 'jobs', 'log', 'ml', 'monitor', 'scans']
+__version__ = "0.1.0"

sparkkflow-0.1.0/sparkkflow/atom_run.py

@@ -0,0 +1,13 @@
+"""Entry point for an atomic-position scan."""
+
+from .atom_scan import atom_scan
+
+
+def main() -> None:
+    aps = atom_scan(task='Ni2FeGa', cpus=32, runtime='24:00:00',
+                    a=[5.77], b=[5.77], c=[5.77])
+    print(aps.run())
+
+
+if __name__ == "__main__":
+    main()

sparkkflow-0.1.0/sparkkflow/atom_scan.py

@@ -0,0 +1,73 @@
+"""Atomic-position parameter scan."""
+
+import logging
+from typing import List, Optional, Sequence
+
+import numpy as np
+
+from .jobs import submitter
+
+logger = logging.getLogger(__name__)
+
+
+class atom_scan:
+    """Sweep lattice parameters (a, b, c) and submit one job per combination."""
+
+    def __init__(self,
+                 task: Optional[str] = None,
+                 a: Optional[Sequence[float]] = None,
+                 b: Optional[Sequence[float]] = None,
+                 c: Optional[Sequence[float]] = None,
+                 cpus: Optional[int] = None,
+                 email: str = '',
+                 email_notify: str = '',
+                 runtime: str = '') -> None:
+        self.task = task
+        self.job_ids: List[str] = []
+        self.job_names: List[str] = []
+        self.job_paths: List[str] = []
+        self.js = submitter(
+            scheduler_type='sge',
+            number_of_requested_cpus=cpus,
+            email_adress=email,
+            email_notification=email_notify,
+            runtime=runtime,
+        )
+        self.a = self._check(a)
+        self.b = self._check(b)
+        self.c = self._check(c)
+
+    @staticmethod
+    def _check(rng: Optional[Sequence[float]]) -> Sequence[float]:
+        if not rng:
+            raise ValueError("Atomic position range is required (a, b, c).")
+        return rng
+
+    @staticmethod
+    def _expand(rng: Sequence[float]) -> List[float]:
+        if len(rng) == 1:
+            logger.warning("Only one atomic position provided.")
+            return [rng[0]]
+        if len(rng) == 2:
+            logger.warning("No range step provided; defaulting to 0.01.")
+            return list(np.arange(rng[0], rng[1], 0.01))
+        return list(np.arange(rng[0], rng[1], rng[2]))
+
+    def run(self) -> dict:
+        for pa in self._expand(self.a):
+            for pb in self._expand(self.b):
+                for pc in self._expand(self.c):
+                    logger.info(f"Submitting position ({pa}, {pb}, {pc})")
+                    res = self.js.submit(
+                        task=self.task,
+                        input_sets=[(pa, pb, pc)],
+                        files=[],
+                    )
+                    self.job_ids.extend(res['job_ids'])
+                    self.job_names.extend(res['job_names'])
+                    self.job_paths.extend(res['job_paths'])
+        return {
+            'job_ids': self.job_ids,
+            'job_names': self.job_names,
+            'job_paths': self.job_paths,
+        }

sparkkflow-0.1.0/sparkkflow/calc_arpes.py

@@ -0,0 +1,49 @@
+import os
+import sys
+from ase2sprkkr import SPRKKR 
+import shutil
+import glob
+from FinalStateDamping.ImFinal import Fitkrasovskii_rpa
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+
+#executable_suffix='9.2devnrep1')
+###################################
+task = 'ARPES'
+polarization = sys.argv[1]
+i = int(sys.argv[2])
+j = int(sys.argv[3])
+l = int(sys.argv[4])
+IM_FINAL_EV=Fitkrasovskii_rpa( int(sys.argv[2]))
+print('IM_FINAL_EV',IM_FINAL_EV)
+####################################
+
+calculator = SPRKKR(mpi=True,executable_suffix='9.2CMOM')
+calculator.change_task('arpes') 
+calculator.input_parameters.CONTROL.PRINT = 0
+calculator.input_parameters.CONTROL.NOHFF=True
+calculator.input_parameters.CONTROL.KRMT=0
+calculator.input_parameters.CONTROL.KRWS=1
+calculator.input_parameters.TASK.STRVER = 0
+calculator.input_parameters.TASK.IQ_AT_SURF=9
+calculator.input_parameters.TAU.NKTAB=1000
+calculator.input_parameters.ENERGY.IMV_FIN_EV=IM_FINAL_EV
+calculator.input_parameters.ENERGY.IMV_INI_EV=0.03
+calculator.input_parameters.ENERGY.EWORK_EV=4.5
+calculator.input_parameters.ENERGY.EMINEV=-3.0
+calculator.input_parameters.ENERGY.EMAXEV=-1.1
+calculator.input_parameters.ENERGY.NE=100
+calculator.input_parameters.SPEC_EL.KA = [2.0, 0.0]
+calculator.input_parameters.SPEC_EL.K1 = [-4.0, 0.0]
+calculator.input_parameters.SPEC_EL.NK1 = 100
+calculator.input_parameters.SPEC_STR.N_LAYER = 20
+calculator.input_parameters.SPEC_STR.NLAT_G_VEC=55
+calculator.input_parameters.SPEC_PH.EPHOT = 0.0 + i
+calculator.input_parameters.SPEC_PH.POL_P = polarization
+calculator.input_parameters.SPEC_PH.PHI=0.0+j
+calculator.input_parameters.SPEC_PH.THETA=45.0
+calculator.input_parameters.SPEC_STR.SURF_BAR= [0.35,0.35]
+#calculator.input_parameters.SPEC.FEGFINAL=True
+calculator.input_parameters.SPEC_STR.TRANSP_BAR=True
+calculator.calculate(potential='WSe2.pot_new')

sparkkflow-0.1.0/sparkkflow/calc_ni2fega.py

@@ -0,0 +1,61 @@
+from ase.spacegroup import crystal
+import ase
+from ase.io import write
+from ase.visualize import view
+from ase2sprkkr import SPRKKR
+from ase2sprkkr.sprkkr.sprkkr_atoms import SPRKKRAtoms
+import os
+import sys
+import shutil
+from ase.build import bulk
+from ase import Atoms
+# Define lattice parameters and basis
+
+a = float(sys.argv[1])
+b = float(sys.argv[2])
+c = float(sys.argv[3])
+
+# Rest of your script...
+
+
+cell=[]
+cell=[a,b,c]
+## define the task for the submitter
+
+task=sys.argv[4]
+
+
+# Create crystal and determine the spacegroup
+Ni2FeGa = crystal(symbols=['Ni','Ni','Fe','Ga'],
+                  basis=[[0.25, 0.25, 0.25], [0.75, 0.75, 0.75],[0.5,0.5,0.5],[0.0,0.0,0.0]], spacegroup=225,
+                  cellpar=[a, b, c, 90., 90., 90.],pbc=True,primitive_cell=True)
+# Promote the ASE atoms to SPRKKRAtoms
+Ni2FeGa = SPRKKRAtoms.promote_ase_atoms(Ni2FeGa)
+
+# Options for input file
+opts = {
+    'CONTROL.KRMT': 4,
+    'CONTROL.KRWS': 1,
+    'ENERGY.EMIN':-0.52,
+    'SITES.NL': 4,
+    'MODE.LLOYD': True,
+    'TAU.BZINT': 'POINTS',
+    'TAU.NKTAB': 1000,
+    'SCF.VXC': 'VWN',
+    'SCF.NITER': 700,
+    'SCF.MIX': 0.1,
+    'SCF.TOL': 1E-5,
+    'SCF.ISTBRY': 1,
+}
+
+# Write starting potential and input file
+calculator = SPRKKR(atoms=Ni2FeGa)
+#calculator.save_input(input_file='Ni2FeGa.inp', potential_file='Ni2FeGa.pot')
+    
+#perform scf calculations
+out=calculator.calculate(mpi=['/opt/openmpi/bin/mpirun','-np','32'], options=opts)
+
+
+
+
+

sparkkflow-0.1.0/sparkkflow/cli.py

@@ -0,0 +1,261 @@
+"""Sparkkflow command line interface."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import sys
+import time
+from datetime import datetime
+from typing import Any
+
+from . import config as cfg
+from . import log as logmod
+from . import ml
+from . import monitor as mon
+from .jobs import submitter
+from .scans import scans
+
+logger = logmod.get_logger(__name__)
+
+
+def parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog='sparkkflow',
+        description="Sparkkflow — ARPES workflow with ML polarization calibration",
+    )
+    p.add_argument('--config', '-c', default='config.yaml')
+    p.add_argument('--debug', '-d', action='store_true')
+    p.add_argument('--scheduler', choices=['slurm', 'sge'])
+    p.add_argument('--oscar-db')
+
+    sub = p.add_subparsers(dest='command')
+
+    s = sub.add_parser('scan', help='Run ARPES scan')
+    s.add_argument('--energy-range', nargs=2, type=int, metavar=('START', 'END'))
+    s.add_argument('--energy-step', type=int, default=1)
+    s.add_argument('--polarization', nargs='+')
+    s.add_argument('--dicho', action='store_true')
+    s.add_argument('--theta-analyzer', type=float)
+    s.add_argument('--theta-photon', type=float)
+    s.add_argument('--rotate', type=float)
+    s.add_argument('--auto-ingest', action='store_true')
+    s.add_argument('--wait', action='store_true', help='Wait for completion and ingest')
+    s.add_argument('--no-array', action='store_true', help='Disable job array submission')
+    s.add_argument('--poll-interval', type=int, default=60, help='Seconds between polls when waiting')
+
+    g = sub.add_parser('generate', help='Generate ML training data')
+    g.add_argument('--energy-range', nargs=2, type=int, metavar=('START', 'END'))
+    g.add_argument('--fine-grid', action='store_true')
+    g.add_argument('--wait', action='store_true', help='Wait for completion and ingest')
+    g.add_argument('--no-array', action='store_true', help='Disable job array submission')
+
+    t = sub.add_parser('train', help='Train polarization model')
+    t.add_argument('--model-path', required=True)
+    t.add_argument('--query-filter')
+    t.add_argument('--limit', type=int)
+
+    pr = sub.add_parser('predict', help='Predict optimal polarization')
+    pr.add_argument('--model-path', required=True)
+    pr.add_argument('--energy', type=float, required=True)
+    pr.add_argument('--formula')
+    pr.add_argument('--task', default='ARPES')
+    pr.add_argument('--energy-tolerance', type=float, default=5.0)
+
+    m = sub.add_parser('monitor', help='Monitor job status')
+    m.add_argument('--job-ids', help='Comma-separated job IDs')
+    m.add_argument('--scripts', help='Comma-separated script paths (for resubmit)')
+    m.add_argument('--continuous', action='store_true')
+    m.add_argument('--interval', type=int, default=60)
+
+    i = sub.add_parser('ingest', help='Ingest completed jobs into OSCARpes')
+    i.add_argument('--dry-run', action='store_true', help='Show what would be ingested without doing it')
+
+    sub.add_parser('doctor', help='Check environment and tooling')
+
+    return p
+
+
+def _sched_params(c: Any, kind: str) -> dict:
+    return dict(c.scheduler.sge if kind == 'sge' else c.scheduler.slurm)
+
+
+def _runner(args, c: Any, ml_mode: bool = False) -> scans:
+    kind = args.scheduler or c.scheduler.default_type
+    return scans(
+        oscar_db_path=c.oscarpes.database_path if c.oscarpes.enabled else None,
+        scheduler_type=kind,
+        auto_ingest=getattr(args, 'auto_ingest', False) or c.oscarpes.auto_ingest,
+        ml_mode=ml_mode,
+        **_sched_params(c, kind),
+    )
+
+
+def cmd_scan(args, c: Any) -> None:
+    logger.info("Starting ARPES scan")
+    runner = _runner(args, c)
+    r = runner.run(
+        energy_range=tuple(args.energy_range) if args.energy_range else None,
+        energy_step=args.energy_step,
+        dicho=args.dicho,
+        pol=args.polarization,
+        rotate=args.rotate,
+        theta_analyzer=args.theta_analyzer,
+        theta_photon=args.theta_photon,
+        wait=args.wait,
+        poll_interval=args.poll_interval,
+    )
+    logger.info(f"ARPES scan submitted: {len(r['job_ids'])} jobs")
+
+
+def cmd_generate(args, c: Any) -> None:
+    logger.info("Generating ML training data")
+    runner = _runner(args, c, ml_mode=True)
+    r = runner.run(
+        energy_range=tuple(args.energy_range) if args.energy_range else None,
+        ml_mode=True,
+        wait=args.wait,
+        poll_interval=getattr(args, 'poll_interval', 60),
+    )
+    out = f"ml_dataset_{len(r['job_ids'])}_samples.json"
+    runner.export(out)
+    logger.info(f"Generated {len(r['job_ids'])} jobs; dataset → {out}")
+
+
+def cmd_train(args, c: Any) -> None:
+    logger.info("Training polarization model")
+    qf = json.loads(args.query_filter) if args.query_filter else None
+    res = ml.train(config_path=args.config, query_filter=qf, save_path=args.model_path)
+    logger.info(f"Model saved to {args.model_path}")
+    logger.info(f"Best val loss: {res['best_val_loss']:.6f}")
+
+
+def cmd_predict(args, c: Any) -> None:
+    logger.info("Predicting optimal polarization")
+    cond: dict = {
+        'photon_energy': args.energy,
+        'energy_tolerance': args.energy_tolerance,
+        'task': args.task,
+    }
+    if args.formula:
+        cond['formula'] = args.formula
+    res = ml.predict(model_path=args.model_path, experimental_conditions=cond,
+                     config_path=args.config)
+    if res.get('status') == 'success':
+        logger.info(f"Optimal polarization: {res['optimal_polarization']}")
+        for k in ('s1', 's2', 's3'):
+            logger.info(
+                f"  {k.upper()}: {res['optimal_stokes'][k]:+.3f} "
+                f"± {res['uncertainty'][k]:.3f}"
+            )
+        logger.info(f"Based on {res['n_similar_calculations']} similar calculations")
+    else:
+        logger.error(f"Prediction failed: {res.get('message')}")
+
+
+def cmd_monitor(args, c: Any) -> None:
+    if not args.job_ids:
+        logger.error("No job IDs provided")
+        return
+    job_ids = args.job_ids.split(',')
+    scripts = args.scripts.split(',') if args.scripts else []
+    if scripts and args.continuous:
+        mon.watch(job_ids, scripts, poll_interval=args.interval)
+        return
+    while True:
+        snap = mon.status(job_ids)
+        ts = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        logger.info(f"[{ts}] {snap}")
+        if not args.continuous:
+            return
+        time.sleep(args.interval)
+
+
+def cmd_ingest(args, c: Any) -> None:
+    """Ingest completed jobs into OSCARpes."""
+    logger.info("Ingesting completed jobs into OSCARpes")
+    js = submitter(
+        scheduler_type=c.scheduler.default_type,
+        oscar_db_path=c.oscarpes.database_path if c.oscarpes.enabled else None,
+        auto_ingest=False,
+    )
+    ingested = js.ingest_completed(dry_run=args.dry_run)
+    if args.dry_run:
+        logger.info(f"[DRY-RUN] Would ingest {len(ingested)} jobs")
+    else:
+        logger.info(f"Successfully ingested {len(ingested)} jobs")
+
+
+def cmd_doctor(args, c: Any) -> None:
+    """Check environment, scheduler binaries, and OSCARpes reachability."""
+    ok = True
+    for tool in ('qsub', 'qstat', 'qacct', 'sbatch', 'squeue'):
+        path = shutil.which(tool)
+        logger.info(f"{tool}: {'found at ' + path if path else 'NOT FOUND'}")
+    try:
+        import oscarpes  # noqa: F401
+        logger.info("oscarpes: importable")
+    except ImportError:
+        logger.warning("oscarpes: not installed (ML ingest disabled)")
+        ok = False
+    try:
+        import torch  # noqa: F401
+        logger.info("torch: importable")
+    except ImportError:
+        logger.warning("torch: not installed (ML pipeline disabled)")
+        ok = False
+    db = c.oscarpes.database_path
+    logger.info(f"OSCARpes db path: {db} (enabled={c.oscarpes.enabled})")
+    sys.exit(0 if ok else 1)
+
+
+COMMANDS = {
+    'scan': cmd_scan,
+    'generate': cmd_generate,
+    'train': cmd_train,
+    'predict': cmd_predict,
+    'monitor': cmd_monitor,
+    'ingest': cmd_ingest,
+    'doctor': cmd_doctor,
+}
+
+
+def main() -> None:
+    args = parser().parse_args()
+    if not args.command:
+        parser().print_help()
+        sys.exit(1)
+
+    mgr = cfg.get_config_manager(args.config)
+    c = mgr.config
+
+    if args.debug:
+        c.general['debug_mode'] = True
+        c.general['log_level'] = 'DEBUG'
+    if args.scheduler:
+        c.scheduler.default_type = args.scheduler
+    if args.oscar_db:
+        c.oscarpes.database_path = args.oscar_db
+
+    logmod.setup_logging({
+        'log_level': c.general.get('log_level', 'INFO'),
+        'log_dir': c.general.get('log_dir', 'logs'),
+        'console_output': True,
+        'file_output': True,
+        'json_output': c.general.get('debug_mode', False),
+    })
+
+    logger.info(f"Sparkkflow command: {args.command}")
+    try:
+        COMMANDS[args.command](args, c)
+    except Exception as e:
+        logger.error(f"Command failed: {e}")
+        if c.general.get('debug_mode', False):
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()