mossview 1.0.0__tar.gz

mossview-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jose Luiz Bruiani Barco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mossview-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+prune legado

mossview-1.0.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: mossview
+Version: 1.0.0
+Summary: Um sistema para leitura, processamento e visualização de dados Mössbauer
+Author-email: Seu Nome <seu.email@exemplo.com>
+License: MIT
+Project-URL: Homepage, https://github.com/seu-usuario/mossview
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: matplotlib>=3.3.0
+Dynamic: license-file
+
+# MossView
+
+MossView is a command-line tool for reading Mössbauer spectra and plotting relative transmission. The main application is [`core-app/mossview.py`](core-app/mossview.py). It reads counts from a `.mos` file and, when it finds an associated `.job` file, uses its metadata for the plot title and velocity scale.
+
+## Requirements
+
+- Python 3.8 or later, as declared in `pyproject.toml`.
+- Dependencies listed in [`requirements.txt`](requirements.txt): NumPy and Matplotlib, with their transitive dependencies pinned there.
+
+Install the dependencies in a virtual environment if desired:
+
+```bash
+python -m venv .venv
+# Windows PowerShell
+.venv\Scripts\Activate.ps1
+# macOS or Linux
+source .venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+## Usage
+
+Run from the repository root and pass a `.mos` or `.job` file:
+
+```bash
+python core-app/mossview.py data-control/b025a-26.mos
+python core-app/mossview.py data-control/b025adi.job
+```
+
+When given a `.job`, MossView tries to locate the `.mos` file named near the beginning of the job file, then falls back to a file with the same base name. When given a `.mos`, it looks for a `.job` that references it or has the same base name. Paths are checked as provided, then relative to the script directory.
+
+The program prints progress and saves a PNG beside the `.mos` file with the same base name. It also opens an interactive Matplotlib window; close the window to end the process.
+
+## Processing flow
+
+1. Resolves the input path and finds the associated `.mos` and `.job` files.
+2. Reads recognized metadata from the `.job`'s `&DATA ... &END` block: `VMAX` (absolute value), `ND`, and `TRIANG`. The plot uses `VMAX`, defaulting to 10 mm/s when unavailable. `ND` and `TRIANG` are read but do not affect current processing.
+3. Reads counts from the `.mos`. The parser accepts XML containing a `<data>` element, as well as text containing numbers. It can read the XML `time` attribute, but does not currently use it in the plot.
+4. Builds a linear velocity scale from `-VMAX` to `+VMAX`, with one point per count.
+5. Calculates relative transmission as `count / maximum_count × 100` and plots Poisson error bars as `√count / maximum_count × 100`.
+6. Saves and displays the plot.
+
+## `&PARAM` block validation
+
+When a `.job` file is available, the program examines assignments only inside the `&PARAM ... &END` block. It compares selected parameters with final values found in tables in the same file. It also checks `ARX` values above 0.5 mm/s when no applicable reference is available. If it finds discrepancies, it writes a copy with the `-updated.job` suffix, reports the changes, and uses that copy. The original `.job` is not overwritten by this process.
+
+This correction is a heuristic for numeric discrepancies and `ARX` values. It is not a complete NORMOS format validator or a guarantee of physical correctness. Review the `-updated.job` file before using it with another program.
+
+## Repository components
+
+| Path | Purpose |
+| --- | --- |
+| `core-app/mossview.py` | Main application: file reading, association, limited validation, and plotting. |
+| `data-control/` | Local sample `.mos`, `.job`, and image files. This directory is ignored by Git. |
+| `legado/main.py` | Independent plotting simulator for damped sine waves and Lissajous curves; it is not called by the current MossView application. |
+| `legado/executables/` | Historical DOS/MBPLOT-related executables, separate from the main application. |
+| `website/` | Minimal website content; it does not provide a working viewer interface. |
+| `pyproject.toml` | Package metadata and Semantic Release configuration. |
+| `.github/workflows/` | Release and PyPI publishing automation. |
+
+## Current scope and limitations
+
+- The available interface is a CLI with an interactive plot; there is no dedicated GUI or web application.
+- The velocity axis is always linear and symmetric. The program does not use `ND` or `TRIANG` to reconstruct other acquisition geometries.
+- The permissive text parser extracts numeric tokens but does not support every possible `.mos` format.
+- `pyproject.toml` sets `packages = []` and defines no console command. Run the script directly as shown above; the publishing configuration alone does not provide an installed CLI.
+- `legado/README.md` describes a historical system and its executables, not the current implementation.
+
+## Development and releases
+
+Automatic versioning is configured for the `main` and `beta` branches with Python Semantic Release. The publishing workflow builds and uploads the package to PyPI when a GitHub release is published. Packaging configuration and workflows are still evolving; to run the tool locally, use the commands in the Usage section.
+
+## License
+
+Distributed under the MIT License. See [`LICENSE`](LICENSE).

mossview-1.0.0/README.md

@@ -0,0 +1,75 @@
+# MossView
+
+MossView is a command-line tool for reading Mössbauer spectra and plotting relative transmission. The main application is [`core-app/mossview.py`](core-app/mossview.py). It reads counts from a `.mos` file and, when it finds an associated `.job` file, uses its metadata for the plot title and velocity scale.
+
+## Requirements
+
+- Python 3.8 or later, as declared in `pyproject.toml`.
+- Dependencies listed in [`requirements.txt`](requirements.txt): NumPy and Matplotlib, with their transitive dependencies pinned there.
+
+Install the dependencies in a virtual environment if desired:
+
+```bash
+python -m venv .venv
+# Windows PowerShell
+.venv\Scripts\Activate.ps1
+# macOS or Linux
+source .venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+## Usage
+
+Run from the repository root and pass a `.mos` or `.job` file:
+
+```bash
+python core-app/mossview.py data-control/b025a-26.mos
+python core-app/mossview.py data-control/b025adi.job
+```
+
+When given a `.job`, MossView tries to locate the `.mos` file named near the beginning of the job file, then falls back to a file with the same base name. When given a `.mos`, it looks for a `.job` that references it or has the same base name. Paths are checked as provided, then relative to the script directory.
+
+The program prints progress and saves a PNG beside the `.mos` file with the same base name. It also opens an interactive Matplotlib window; close the window to end the process.
+
+## Processing flow
+
+1. Resolves the input path and finds the associated `.mos` and `.job` files.
+2. Reads recognized metadata from the `.job`'s `&DATA ... &END` block: `VMAX` (absolute value), `ND`, and `TRIANG`. The plot uses `VMAX`, defaulting to 10 mm/s when unavailable. `ND` and `TRIANG` are read but do not affect current processing.
+3. Reads counts from the `.mos`. The parser accepts XML containing a `<data>` element, as well as text containing numbers. It can read the XML `time` attribute, but does not currently use it in the plot.
+4. Builds a linear velocity scale from `-VMAX` to `+VMAX`, with one point per count.
+5. Calculates relative transmission as `count / maximum_count × 100` and plots Poisson error bars as `√count / maximum_count × 100`.
+6. Saves and displays the plot.
+
+## `&PARAM` block validation
+
+When a `.job` file is available, the program examines assignments only inside the `&PARAM ... &END` block. It compares selected parameters with final values found in tables in the same file. It also checks `ARX` values above 0.5 mm/s when no applicable reference is available. If it finds discrepancies, it writes a copy with the `-updated.job` suffix, reports the changes, and uses that copy. The original `.job` is not overwritten by this process.
+
+This correction is a heuristic for numeric discrepancies and `ARX` values. It is not a complete NORMOS format validator or a guarantee of physical correctness. Review the `-updated.job` file before using it with another program.
+
+## Repository components
+
+| Path | Purpose |
+| --- | --- |
+| `core-app/mossview.py` | Main application: file reading, association, limited validation, and plotting. |
+| `data-control/` | Local sample `.mos`, `.job`, and image files. This directory is ignored by Git. |
+| `legado/main.py` | Independent plotting simulator for damped sine waves and Lissajous curves; it is not called by the current MossView application. |
+| `legado/executables/` | Historical DOS/MBPLOT-related executables, separate from the main application. |
+| `website/` | Minimal website content; it does not provide a working viewer interface. |
+| `pyproject.toml` | Package metadata and Semantic Release configuration. |
+| `.github/workflows/` | Release and PyPI publishing automation. |
+
+## Current scope and limitations
+
+- The available interface is a CLI with an interactive plot; there is no dedicated GUI or web application.
+- The velocity axis is always linear and symmetric. The program does not use `ND` or `TRIANG` to reconstruct other acquisition geometries.
+- The permissive text parser extracts numeric tokens but does not support every possible `.mos` format.
+- `pyproject.toml` sets `packages = []` and defines no console command. Run the script directly as shown above; the publishing configuration alone does not provide an installed CLI.
+- `legado/README.md` describes a historical system and its executables, not the current implementation.
+
+## Development and releases
+
+Automatic versioning is configured for the `main` and `beta` branches with Python Semantic Release. The publishing workflow builds and uploads the package to PyPI when a GitHub release is published. Packaging configuration and workflows are still evolving; to run the tool locally, use the commands in the Usage section.
+
+## License
+
+Distributed under the MIT License. See [`LICENSE`](LICENSE).

mossview-1.0.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mossview"  # Nome do pacote no PyPI
+version = "1.0.0"  # Versão inicial do software
+description = "Um sistema para leitura, processamento e visualização de dados Mössbauer"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Seu Nome", email = "seu.email@exemplo.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "numpy>=1.20.0",
+    "matplotlib>=3.3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/seu-usuario/mossview"
+
+# Configuração correta para o padrão src/
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["mossview*"]
+
+# Configuração de automação de release e versionamento
+[tool.semantic_release]
+version_toml = [
+    "pyproject.toml:project.version",
+]
+commit_parser = "conventional"
+build_command = "pip install build && python -m build"
+
+[tool.semantic_release.branches.main]
+match = "^main$"
+prerelease = false
+
+[tool.semantic_release.branches.beta]
+match = "^beta$"
+prerelease = true
+prerelease_token = "beta"

mossview-1.0.0/setup.cfg

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

mossview-1.0.0/src/mossview/cli.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+MossView - Mössbauer spectrum viewer (.mos and .job)
+with validation and filtering restricted to parameters in the &PARAM block.
+"""
+
+import sys
+import os
+import re
+import argparse
+from pathlib import Path
+import xml.etree.ElementTree as ET
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def resolve_file_path(input_path_str: str) -> Path:
+    """
+    Resolve the input file path using these rules:
+    1. If the absolute path exists, return it.
+    2. If the path exists in the current working directory (CWD), return it.
+    3. If the path exists in the Python script directory, return it.
+    """
+    path = Path(input_path_str)
+
+    if path.is_absolute() and path.exists():
+        return path.resolve()
+
+    if path.exists():
+        return path.resolve()
+
+    script_dir = Path(__file__).parent.resolve()
+    script_relative_path = script_dir / input_path_str
+    if script_relative_path.exists():
+        return script_relative_path.resolve()
+
+    return path.resolve()
+
+
+def parse_job_file(job_path: Path) -> dict:
+    """
+    Read a NORMOS .JOB file and extract display metadata and raw content
+    for analysis of the &PARAM block.
+    """
+    info = {
+        'mos_filename': None,
+        'title': '',
+        'vmax': 10.0,
+        'nd': None,
+        'triang': True,
+        'raw_content': ''
+    }
+
+    try:
+        with open(job_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+            info['raw_content'] = content
+            lines = [line.strip() for line in content.splitlines() if line.strip()]
+
+        for line in lines[:6]:
+            if line.lower().endswith('.mos'):
+                info['mos_filename'] = line
+                break
+
+        title_lines = []
+        for line in lines:
+            if line.startswith('*'):
+                cleaned = line.strip('*').strip()
+                if cleaned:
+                    title_lines.append(cleaned)
+        if title_lines:
+            info['title'] = " | ".join(title_lines)
+
+        data_match = re.search(r'&DATA(.*?)&END', content, re.DOTALL | re.IGNORECASE)
+        if data_match:
+            data_block = data_match.group(1)
+
+            vmax_m = re.search(r'VMAX\s*=\s*([+-]?\d+\.?\d*)', data_block, re.IGNORECASE)
+            if vmax_m:
+                info['vmax'] = abs(float(vmax_m.group(1)))
+
+            nd_m = re.search(r'ND\s*=\s*(\d+)', data_block, re.IGNORECASE)
+            if nd_m:
+                info['nd'] = int(nd_m.group(1))
+
+            triang_m = re.search(r'TRIANG\s*=\s*\.?(TRUE|FALSE)\.?', data_block, re.IGNORECASE)
+            if triang_m:
+                info['triang'] = (triang_m.group(1).upper() == 'TRUE')
+
+    except Exception as e:
+        print(f"[WARNING] Error reading metadata from .JOB file: {e}")
+
+    return info
+
+
+def extract_reference_values(content: str) -> dict:
+    """
+    Extract reference/final values from report tables in the .JOB/.RES file.
+    """
+    refs = {}
+
+    # 1. Parameter table: "Index Name Initial Final Error"
+    pattern_index = re.compile(
+        r'^\s*\d+\s+([A-Z]+)\s+[+-]?\d+\.?\d*(?:[eE][+-]?\d+)?\s+([+-]?\d+\.?\d*(?:[eE][+-]?\d+)?)',
+        re.MULTILINE
+    )
+    for match in pattern_index.finditer(content):
+        param_name = match.group(1).upper()
+        try:
+            refs[param_name] = float(match.group(2))
+        except ValueError:
+            pass
+
+    # 2. "Sub. #Lines Area (mm/s)" table for mapping subspectrum areas (ARX)
+    if "Sub. #Lines" in content:
+        sub_block = content.split("Sub. #Lines")[1]
+        pattern_area = re.compile(r'^\s*(\d+)\s+\d+\s+([+-]?\d+\.?\d*(?:[eE][+-]?\d+)?)', re.MULTILINE)
+        for match in pattern_area.finditer(sub_block):
+            sub_idx = match.group(1)
+            try:
+                refs[f"ARX({sub_idx})"] = float(match.group(2))
+            except ValueError:
+                pass
+
+    return refs
+
+
+def validate_and_filter_param_block(job_path: Path, content: str) -> tuple[str, Path, list[str]]:
+    """
+    Validate and edit ONLY data inside the &PARAM ... &END block.
+    Check numeric discrepancies (such as decimal-place shifts in ARX)
+    against report data or physical limits.
+    """
+    param_match = re.search(r'(&PARAM\b.*?&END)', content, re.DOTALL | re.IGNORECASE)
+    if not param_match:
+        return content, job_path, []
+
+    original_param_block = param_match.group(1)
+    warnings = []
+    refs = extract_reference_values(content)
+
+    # Regular expression to capture KEY(INDEX)=VALUE assignments
+    param_kv_pattern = re.compile(r'([A-Z0-9_]+\(\d+\))\s*=\s*([+-]?\d+\.?\d*(?:[eE][+-]?\d+)?)', re.IGNORECASE)
+
+    def replace_param(match):
+        key = match.group(1).upper()
+        raw_val = match.group(2)
+        try:
+            val = float(raw_val)
+        except ValueError:
+            return match.group(0)
+
+        base_name = re.sub(r'\(\d+\)', '', key)
+        target_val = refs.get(key) or refs.get(base_name)
+
+        if target_val is not None:
+            # Check for a significant deviation from the expected value (e.g. a decimal-place error)
+            if abs(val - target_val) > 1e-4:
+                formatted_target = f"{target_val:.5f}".rstrip('0').rstrip('.') if abs(target_val) < 100 else f"{target_val}"
+                warnings.append(
+                    f"Parameter {key}={val} is outside the expected range. Corrected to {key}={formatted_target} (expected: {target_val})."
+                )
+                return match.group(0).replace(raw_val, formatted_target)
+
+        # Fallback safeguard if ARX exceeds the typical limit (> 0.5 mm/s) without an available table
+        if base_name == "ARX" and val > 0.5:
+            corrected_val = val / 10.0
+            formatted_target = f"{corrected_val:.5f}".rstrip('0').rstrip('.')
+            warnings.append(
+                f"Parameter {key}={val} exceeds the expected spectrum limit. Corrected to {key}={formatted_target}."
+            )
+            return match.group(0).replace(raw_val, formatted_target)
+
+        return match.group(0)
+
+    new_param_block = param_kv_pattern.sub(replace_param, original_param_block)
+
+    if warnings and job_path:
+        new_content = content.replace(original_param_block, new_param_block)
+        stem = job_path.stem
+        updated_job_path = job_path if stem.endswith("-updated") else job_path.parent / f"{stem}-updated.job"
+
+        with open(updated_job_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+
+        return new_content, updated_job_path, warnings
+
+    return content, job_path, warnings
+
+
+def parse_mos_file(mos_path: Path) -> tuple[np.ndarray, dict]:
+    """
+    Read counts from a .MOS file in XML (WisSoft) or plain text/ASCII format.
+    """
+    counts = []
+    meta = {}
+
+    try:
+        tree = ET.parse(mos_path)
+        root = tree.getroot()
+        data_elem = root.find('data')
+        if data_elem is not None and data_elem.text:
+            text_data = data_elem.text.strip()
+            counts = [float(val) for val in text_data.split()]
+            if 'time' in data_elem.attrib:
+                meta['time'] = float(data_elem.attrib['time'])
+            return np.array(counts, dtype=float), meta
+    except Exception:
+        pass
+
+    with open(mos_path, 'r', encoding='utf-8', errors='ignore') as f:
+        content = f.read()
+
+    data_match = re.search(r'<data[^>]*>(.*?)</data>', content, re.DOTALL | re.IGNORECASE)
+    if data_match:
+        text_data = data_match.group(1).strip()
+        tokens = text_data.split()
+        counts = [float(v) for v in tokens if v.replace('.', '', 1).lstrip('-').isdigit()]
+        return np.array(counts, dtype=float), meta
+
+    tokens = content.split()
+    for t in tokens:
+        try:
+            counts.append(float(t))
+        except ValueError:
+            continue
+
+    if not counts:
+        raise ValueError(f"Could not extract numeric data from file {mos_path.name}")
+
+    return np.array(counts, dtype=float), meta
+
+
+def locate_associated_files(target_path: Path):
+    """
+    Identify the .MOS and .JOB files from the path provided by the user.
+    """
+    job_path = None
+    mos_path = None
+    job_info = {}
+
+    if target_path.suffix.lower() == '.job':
+        job_path = target_path
+        job_info = parse_job_file(job_path)
+
+        if job_info.get('mos_filename'):
+            candidate = job_path.parent / job_info['mos_filename']
+            if candidate.exists():
+                mos_path = candidate
+            else:
+                for f in job_path.parent.iterdir():
+                    if f.name.lower() == job_info['mos_filename'].lower():
+                        mos_path = f
+                        break
+
+        if not mos_path:
+            candidate = job_path.with_suffix('.MOS')
+            if candidate.exists():
+                mos_path = candidate
+            else:
+                candidate_lower = job_path.with_suffix('.mos')
+                if candidate_lower.exists():
+                    mos_path = candidate_lower
+
+    elif target_path.suffix.lower() == '.mos':
+        mos_path = target_path
+
+        possible_jobs = list(mos_path.parent.glob('*.JOB')) + list(mos_path.parent.glob('*.job'))
+        for j_file in possible_jobs:
+            j_info = parse_job_file(j_file)
+            if j_info.get('mos_filename') and j_info['mos_filename'].lower() == mos_path.name.lower():
+                job_path = j_file
+                job_info = j_info
+                break
+
+        if not job_path:
+            candidate = mos_path.with_suffix('.JOB')
+            if candidate.exists():
+                job_path = candidate
+                job_info = parse_job_file(job_path)
+
+    return mos_path, job_path, job_info
+
+
+def calculate_velocity_scale(num_channels: int, vmax: float) -> np.ndarray:
+    """
+    Calculate the velocity scale (in mm/s) for a linear Mössbauer scan.
+    """
+    return np.linspace(-abs(vmax), abs(vmax), num_channels)
+
+
+def plot_mossbauer(velocity: np.ndarray, counts: np.ndarray, title: str, job_name: str, mos_name: str, output_image_path: Path):
+    """
+    Generate a Mössbauer spectrum plot in relative transmission (%) and raw counts.
+    """
+    baseline = np.max(counts)
+    rel_transmission = (counts / baseline) * 100.0
+    errors_rel = (np.sqrt(counts) / baseline) * 100.0
+
+    plt.style.use('seaborn-v0_8-whitegrid' if 'seaborn-v0_8-whitegrid' in plt.style.available else 'default')
+    fig, ax1 = plt.subplots(figsize=(10, 6), dpi=120)
+
+    ax1.errorbar(velocity, rel_transmission, yerr=errors_rel, fmt='o', color='#004080',
+                 ecolor='#80b3ff', elinewidth=0.8, markersize=3, label='Experimental Data', alpha=0.85)
+
+    ax1.axhline(100.0, color='crimson', linestyle='--', linewidth=1.0, label='Baseline (100%)')
+
+    ax1.set_xlabel('Velocity (mm/s)', fontsize=12, fontweight='bold')
+    ax1.set_ylabel('Relative Transmission (%)', fontsize=12, fontweight='bold', color='#004080')
+    ax1.tick_params(axis='y', labelcolor='#004080')
+
+    ax2 = ax1.twinx()
+    ax2.set_ylabel('Total Counts', fontsize=11, color='#555555')
+    min_counts = np.min(counts)
+    ax2.set_ylim((min_counts / baseline) * 100, 100.5)
+    ax2.set_yticks(np.linspace((min_counts / baseline) * 100, 100, 6))
+    ax2.set_yticklabels([f"{int(val * baseline / 100):,}" for val in ax2.get_yticks()])
+    ax2.grid(False)
+
+    display_title = title if title else f"Mossbauer Spectrum - {mos_name}"
+    plt.title(display_title, fontsize=13, fontweight='bold', pad=15)
+
+    info_text = (f"File: {mos_name}\n"
+                 f"JOB: {job_name if job_name else 'None'}\n"
+                 f"Channels: {len(counts)}\n"
+                 f"Vmax: {np.max(np.abs(velocity)):.4f} mm/s\n"
+                 f"Max Count: {int(baseline):,}")
+
+    ax1.text(0.02, 0.05, info_text, transform=ax1.transAxes, fontsize=9,
+             verticalalignment='bottom', bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.85, edgecolor='#ccc'))
+
+    ax1.legend(loc='upper right', frameon=True)
+    fig.tight_layout()
+
+    plt.savefig(output_image_path, dpi=300)
+    print(f"[SUCCESS] Plot saved to: {output_image_path}")
+
+    plt.show()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="MossView - Mössbauer spectrum reader and viewer (.MOS and .JOB)"
+    )
+    parser.add_argument("file", help="File name or full path (.job or .mos)")
+    args = parser.parse_args()
+
+    try:
+        resolved_path = resolve_file_path(args.file)
+    except Exception as e:
+        print(f"[ERROR] Failed to process the specified path: {e}")
+        sys.exit(1)
+
+    if not resolved_path.exists():
+        print(f"[ERROR] File not found:\n  -> {resolved_path}")
+        sys.exit(1)
+
+    print(f"[OK] File found: {resolved_path}")
+
+    mos_path, job_path, job_info = locate_associated_files(resolved_path)
+
+    if not mos_path or not mos_path.exists():
+        print(f"[ERROR] Could not find the .MOS data file associated with {resolved_path.name}")
+        sys.exit(1)
+
+    # 1. Read and validate the &PARAM block in the .JOB file
+    if job_path and job_path.exists():
+        raw_content = job_info.get('raw_content', '')
+        _, updated_job_path, warnings = validate_and_filter_param_block(job_path, raw_content)
+
+        if warnings:
+            print("\n[WARNING] Values outside the expected range were found in the &PARAM block:")
+            for w in warnings:
+                print(f"  -> {w}")
+            print(f"[OK] Updated file with corrected &PARAM block saved to: {updated_job_path}\n")
+            job_path = updated_job_path
+            job_info = parse_job_file(job_path)
+
+    # 2. Read the .MOS data file
+    try:
+        counts, meta = parse_mos_file(mos_path)
+        print(f"[OK] .MOS spectrum loaded: {len(counts)} channels read.")
+    except Exception as e:
+        print(f"[ERROR] Failed to read .MOS file: {e}")
+        sys.exit(1)
+
+    vmax = job_info.get('vmax', 10.0)
+    title = job_info.get('title', '')
+    velocity = calculate_velocity_scale(len(counts), vmax)
+
+    job_name = job_path.name if job_path else "None"
+    mos_name = mos_path.name
+    output_png = mos_path.with_suffix('.png')
+
+    plot_mossbauer(velocity, counts, title, job_name, mos_name, output_png)
+
+
+if __name__ == "__main__":
+    main()

mossview-1.0.0/src/mossview/legado/main.py

@@ -0,0 +1,76 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class MBPlotSimulator:
+    """
+    Simulador da lógica de amostragem, transformação de coordenadas 
+    e geração de gráficos do sistema clássico MBPLOT.
+    """
+    def __init__(self, screen_width=800, screen_height=600):
+        self.screen_width = screen_width
+        self.screen_height = screen_height
+
+    def world_to_screen(self, x_world, y_world, x_min, x_max, y_min, y_max):
+        """
+        Converte coordenadas de mundo (matemáticas) para coordenadas de tela (pixels).
+        """
+        x_screen = ((x_world - x_min) / (x_max - x_min)) * self.screen_width
+        y_screen = self.screen_height - ((y_world - y_min) / (y_max - y_min)) * self.screen_height
+        return x_screen, y_screen
+
+    def generate_damped_sine(self, x_min=0.0, x_max=10.0, num_points=500, alpha=0.5, omega=2.0 * np.pi):
+        """
+        Gera a função de onda amortecida: f(x) = exp(-alpha * x) * sin(omega * x)
+        """
+        x = np.linspace(x_min, x_max, num_points)
+        y = np.exp(-alpha * x) * np.sin(omega * x)
+        return x, y
+
+    def generate_lissajous(self, a=3, b=4, delta=np.pi/2, num_points=1000):
+        """
+        Gera curvas paramétricas de Lissajous: x(t) = sin(a*t + delta), y(t) = sin(b*t)
+        """
+        t = np.linspace(0, 2 * np.pi, num_points)
+        x = np.sin(a * t + delta)
+        y = np.sin(b * t)
+        return x, y
+
+    def plot_function(self, x, y, title="MBPLOT - Visualização de Função"):
+        """
+        Plota o gráfico com estilo retrô similar ao ambiente gráfico DOS.
+        """
+        x_min, x_max = np.min(x), np.max(x)
+        y_min, y_max = np.min(y), np.max(y)
+
+        # Mapeamento para resolução de tela simulada
+        x_pixel, y_pixel = self.world_to_screen(x, y, x_min, x_max, y_min, y_max)
+
+        plt.figure(figsize=(9, 6), facecolor='black')
+        ax = plt.axes()
+        ax.set_facecolor('black')
+
+        # Desenhar linha estilo monitor VGA clássico (Verde / Ciano)
+        plt.plot(x_pixel, y_pixel, color='#00FF66', linewidth=1.5, label='Sinal Processado')
+
+        plt.title(title, color='white', fontsize=12, fontweight='bold')
+        plt.xlabel("Pixel X (Viewport)", color='white')
+        plt.ylabel("Pixel Y (Viewport Invertido)", color='white')
+        plt.tick_params(colors='white')
+        plt.grid(True, color='#333333', linestyle='--')
+        plt.xlim(0, self.screen_width)
+        plt.ylim(self.screen_height, 0) # Invertido igual coordenada de tela
+        plt.legend(facecolor='black', edgecolor='white', labelcolor='white')
+        
+        plt.tight_layout()
+        plt.show()
+
+if __name__ == "__main__":
+    simulator = MBPlotSimulator(screen_width=640, screen_height=480)
+
+    # 1. Plotar Onda Senoidal Amortecida
+    x_func, y_func = simulator.generate_damped_sine(x_min=0, x_max=5, num_points=400, alpha=0.6, omega=4.0*np.pi)
+    simulator.plot_function(x_func, y_func, title="MBPLOT Simulação: Onda Amortecida f(x) = e^(-a*x) * sin(w*x)")
+
+    # 2. Plotar Figura de Lissajous
+    x_liss, y_liss = simulator.generate_lissajous(a=5, b=6, delta=np.pi/4)
+    simulator.plot_function(x_liss, y_liss, title="MBPLOT Simulação: Curva Paramétrica de Lissajous")

mossview-1.0.0/src/mossview.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: mossview
+Version: 1.0.0
+Summary: Um sistema para leitura, processamento e visualização de dados Mössbauer
+Author-email: Seu Nome <seu.email@exemplo.com>
+License: MIT
+Project-URL: Homepage, https://github.com/seu-usuario/mossview
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: matplotlib>=3.3.0
+Dynamic: license-file
+
+# MossView
+
+MossView is a command-line tool for reading Mössbauer spectra and plotting relative transmission. The main application is [`core-app/mossview.py`](core-app/mossview.py). It reads counts from a `.mos` file and, when it finds an associated `.job` file, uses its metadata for the plot title and velocity scale.
+
+## Requirements
+
+- Python 3.8 or later, as declared in `pyproject.toml`.
+- Dependencies listed in [`requirements.txt`](requirements.txt): NumPy and Matplotlib, with their transitive dependencies pinned there.
+
+Install the dependencies in a virtual environment if desired:
+
+```bash
+python -m venv .venv
+# Windows PowerShell
+.venv\Scripts\Activate.ps1
+# macOS or Linux
+source .venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+## Usage
+
+Run from the repository root and pass a `.mos` or `.job` file:
+
+```bash
+python core-app/mossview.py data-control/b025a-26.mos
+python core-app/mossview.py data-control/b025adi.job
+```
+
+When given a `.job`, MossView tries to locate the `.mos` file named near the beginning of the job file, then falls back to a file with the same base name. When given a `.mos`, it looks for a `.job` that references it or has the same base name. Paths are checked as provided, then relative to the script directory.
+
+The program prints progress and saves a PNG beside the `.mos` file with the same base name. It also opens an interactive Matplotlib window; close the window to end the process.
+
+## Processing flow
+
+1. Resolves the input path and finds the associated `.mos` and `.job` files.
+2. Reads recognized metadata from the `.job`'s `&DATA ... &END` block: `VMAX` (absolute value), `ND`, and `TRIANG`. The plot uses `VMAX`, defaulting to 10 mm/s when unavailable. `ND` and `TRIANG` are read but do not affect current processing.
+3. Reads counts from the `.mos`. The parser accepts XML containing a `<data>` element, as well as text containing numbers. It can read the XML `time` attribute, but does not currently use it in the plot.
+4. Builds a linear velocity scale from `-VMAX` to `+VMAX`, with one point per count.
+5. Calculates relative transmission as `count / maximum_count × 100` and plots Poisson error bars as `√count / maximum_count × 100`.
+6. Saves and displays the plot.
+
+## `&PARAM` block validation
+
+When a `.job` file is available, the program examines assignments only inside the `&PARAM ... &END` block. It compares selected parameters with final values found in tables in the same file. It also checks `ARX` values above 0.5 mm/s when no applicable reference is available. If it finds discrepancies, it writes a copy with the `-updated.job` suffix, reports the changes, and uses that copy. The original `.job` is not overwritten by this process.
+
+This correction is a heuristic for numeric discrepancies and `ARX` values. It is not a complete NORMOS format validator or a guarantee of physical correctness. Review the `-updated.job` file before using it with another program.
+
+## Repository components
+
+| Path | Purpose |
+| --- | --- |
+| `core-app/mossview.py` | Main application: file reading, association, limited validation, and plotting. |
+| `data-control/` | Local sample `.mos`, `.job`, and image files. This directory is ignored by Git. |
+| `legado/main.py` | Independent plotting simulator for damped sine waves and Lissajous curves; it is not called by the current MossView application. |
+| `legado/executables/` | Historical DOS/MBPLOT-related executables, separate from the main application. |
+| `website/` | Minimal website content; it does not provide a working viewer interface. |
+| `pyproject.toml` | Package metadata and Semantic Release configuration. |
+| `.github/workflows/` | Release and PyPI publishing automation. |
+
+## Current scope and limitations
+
+- The available interface is a CLI with an interactive plot; there is no dedicated GUI or web application.
+- The velocity axis is always linear and symmetric. The program does not use `ND` or `TRIANG` to reconstruct other acquisition geometries.
+- The permissive text parser extracts numeric tokens but does not support every possible `.mos` format.
+- `pyproject.toml` sets `packages = []` and defines no console command. Run the script directly as shown above; the publishing configuration alone does not provide an installed CLI.
+- `legado/README.md` describes a historical system and its executables, not the current implementation.
+
+## Development and releases
+
+Automatic versioning is configured for the `main` and `beta` branches with Python Semantic Release. The publishing workflow builds and uploads the package to PyPI when a GitHub release is published. Packaging configuration and workflows are still evolving; to run the tool locally, use the commands in the Usage section.
+
+## License
+
+Distributed under the MIT License. See [`LICENSE`](LICENSE).

mossview-1.0.0/src/mossview.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/mossview/cli.py
+src/mossview/gui.py
+src/mossview.egg-info/PKG-INFO
+src/mossview.egg-info/SOURCES.txt
+src/mossview.egg-info/dependency_links.txt
+src/mossview.egg-info/requires.txt
+src/mossview.egg-info/top_level.txt
+src/mossview/legado/main.py

mossview-1.0.0/src/mossview.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mossview-1.0.0/src/mossview.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.20.0
+matplotlib>=3.3.0

mossview-1.0.0/src/mossview.egg-info/top_level.txt

@@ -0,0 +1 @@
+mossview