pyreqifz 0.1.0__tar.gz

pyreqifz-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ernesto Avedillo Carretero
+
+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.

pyreqifz-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: pyreqifz
+Version: 0.1.0
+Summary: Read, edit and repack ReqIF/ReqIFz requirement documents (OMG ReqIF standard)
+Author: Ernesto Avedillo Carretero
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl>=3.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# pyreqif
+
+Librería Python para leer, editar y reempaquetar documentos [ReqIF](https://www.omg.org/spec/ReqIF/) (`.reqif` / `.reqifz`), el estándar OMG usado habitualmente para intercambiar requisitos entre fabricante y proveedor (p.ej. lastenheft de automoción).
+
+Dos clases:
+
+- **`Reqif`**: un único fichero `.reqif`. Lee cada requisito (`SPEC-OBJECT`) con su texto, y dos campos configurables pensados para el flujo proveedor: comentario (`Kommentar Lieferant M`, XHTML) y estado (`Status Lieferant M`, enumerado). Permite editarlos, exportar/importar por Excel (con desplegable de validación para el estado) y detecta las imágenes embebidas en el texto de cada requisito.
+- **`Reqifz`**: un `.reqifz` (zip con uno o varios `.reqif` más sus adjuntos). Extrae a un directorio de trabajo, expone cada `.reqif` como un `Reqif`, y reempaqueta todo de vuelta conservando los adjuntos intactos.
+
+## Instalación
+
+```bash
+pip install pyreqif
+```
+
+## Uso básico
+
+```python
+from pyreqif import Reqifz
+
+with Reqifz("lastenheft.reqifz") as pack:
+    for doc in pack:
+        print(doc, "->", len(doc), "requisitos")
+
+    doc = pack.get(0)  # o pack.get("nombre_del_fichero.reqif")
+
+    # leer
+    req = doc.get("_a1b2c3...")
+    print(req.text, req.comment, req.status, req.images)
+
+    # editar (None deja el campo igual, "" lo vacía)
+    doc.update("_a1b2c3...", comment="Aceptado, sin cambios.", status="akzeptiert")
+
+    # exportar/importar por Excel
+    doc.to_excel("requisitos.xlsx")
+    doc.update_from_excel("requisitos_revisado.xlsx")
+
+    # volver a empaquetar con los cambios
+    pack.save("lastenheft_editado.reqifz")
+```
+
+Un `.reqif` suelto (sin comprimir) se usa igual, sin pasar por `Reqifz`:
+
+```python
+from pyreqif import Reqif
+
+doc = Reqif("documento.reqif")
+doc.update("_a1b2c3...", status="Klärungsbedarf")
+doc.save("documento_editado.reqif")
+```
+
+## Nombres de atributo
+
+Por defecto se usan los nombres estándar de ReqIF para el texto (`ReqIF.Text` / `ReqIF.ChapterName` como respaldo) y los nombres de campo de este flujo concreto de proveedor (`Kommentar Lieferant M` / `Status Lieferant M`). Si tu documento usa otros nombres, crea una subclase:
+
+```python
+from pyreqif import Reqif
+
+class MiReqif(Reqif):
+    COMMENT_ATTR = "Supplier Comment"
+    STATUS_ATTR = "Supplier Status"
+```
+
+## Desarrollo
+
+```bash
+uv venv
+uv pip install -e ".[dev]"
+uv run pytest
+```
+
+## Licencia
+
+MIT

pyreqifz-0.1.0/README.md

@@ -0,0 +1,74 @@
+# pyreqif
+
+Librería Python para leer, editar y reempaquetar documentos [ReqIF](https://www.omg.org/spec/ReqIF/) (`.reqif` / `.reqifz`), el estándar OMG usado habitualmente para intercambiar requisitos entre fabricante y proveedor (p.ej. lastenheft de automoción).
+
+Dos clases:
+
+- **`Reqif`**: un único fichero `.reqif`. Lee cada requisito (`SPEC-OBJECT`) con su texto, y dos campos configurables pensados para el flujo proveedor: comentario (`Kommentar Lieferant M`, XHTML) y estado (`Status Lieferant M`, enumerado). Permite editarlos, exportar/importar por Excel (con desplegable de validación para el estado) y detecta las imágenes embebidas en el texto de cada requisito.
+- **`Reqifz`**: un `.reqifz` (zip con uno o varios `.reqif` más sus adjuntos). Extrae a un directorio de trabajo, expone cada `.reqif` como un `Reqif`, y reempaqueta todo de vuelta conservando los adjuntos intactos.
+
+## Instalación
+
+```bash
+pip install pyreqif
+```
+
+## Uso básico
+
+```python
+from pyreqif import Reqifz
+
+with Reqifz("lastenheft.reqifz") as pack:
+    for doc in pack:
+        print(doc, "->", len(doc), "requisitos")
+
+    doc = pack.get(0)  # o pack.get("nombre_del_fichero.reqif")
+
+    # leer
+    req = doc.get("_a1b2c3...")
+    print(req.text, req.comment, req.status, req.images)
+
+    # editar (None deja el campo igual, "" lo vacía)
+    doc.update("_a1b2c3...", comment="Aceptado, sin cambios.", status="akzeptiert")
+
+    # exportar/importar por Excel
+    doc.to_excel("requisitos.xlsx")
+    doc.update_from_excel("requisitos_revisado.xlsx")
+
+    # volver a empaquetar con los cambios
+    pack.save("lastenheft_editado.reqifz")
+```
+
+Un `.reqif` suelto (sin comprimir) se usa igual, sin pasar por `Reqifz`:
+
+```python
+from pyreqif import Reqif
+
+doc = Reqif("documento.reqif")
+doc.update("_a1b2c3...", status="Klärungsbedarf")
+doc.save("documento_editado.reqif")
+```
+
+## Nombres de atributo
+
+Por defecto se usan los nombres estándar de ReqIF para el texto (`ReqIF.Text` / `ReqIF.ChapterName` como respaldo) y los nombres de campo de este flujo concreto de proveedor (`Kommentar Lieferant M` / `Status Lieferant M`). Si tu documento usa otros nombres, crea una subclase:
+
+```python
+from pyreqif import Reqif
+
+class MiReqif(Reqif):
+    COMMENT_ATTR = "Supplier Comment"
+    STATUS_ATTR = "Supplier Status"
+```
+
+## Desarrollo
+
+```bash
+uv venv
+uv pip install -e ".[dev]"
+uv run pytest
+```
+
+## Licencia
+
+MIT

pyreqifz-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyreqifz"
+version = "0.1.0"
+description = "Read, edit and repack ReqIF/ReqIFz requirement documents (OMG ReqIF standard)"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Ernesto Avedillo Carretero" }]
+dependencies = [
+    "openpyxl>=3.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "build>=1.0",
+    "twine>=5.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["pyreqif*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

pyreqifz-0.1.0/setup.cfg

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

pyreqifz-0.1.0/src/pyreqif/__init__.py

@@ -0,0 +1,4 @@
+from .reqif import Reqif, Requirement, ReqifError
+from .reqifz import Reqifz
+
+__all__ = ['Reqif', 'Reqifz', 'Requirement', 'ReqifError']

pyreqifz-0.1.0/src/pyreqif/reqif.py

@@ -0,0 +1,390 @@
+"""Reqif: lectura, edición y exportación de un único documento .reqif."""
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+from openpyxl import Workbook, load_workbook
+from openpyxl.styles import Alignment
+from openpyxl.worksheet.datavalidation import DataValidation
+
+XHTML_NS = 'http://www.w3.org/1999/xhtml'
+
+EXCEL_HEADERS = ['ID', 'Texto', 'Kommentar Lieferant M', 'Status Lieferant M']
+
+_DEFINITION_TAGS = [
+    'ATTRIBUTE-DEFINITION-STRING',
+    'ATTRIBUTE-DEFINITION-XHTML',
+    'ATTRIBUTE-DEFINITION-ENUMERATION',
+    'ATTRIBUTE-DEFINITION-INTEGER',
+    'ATTRIBUTE-DEFINITION-BOOLEAN',
+    'ATTRIBUTE-DEFINITION-DATE',
+]
+
+
+class ReqifError(Exception):
+    pass
+
+
+@dataclass
+class Requirement:
+    """Un SPEC-OBJECT del ReqIF, con los campos relevantes ya resueltos."""
+    id: str
+    text: str
+    is_chapter: bool
+    comment: str
+    status: str
+    images: list[str] = field(default_factory=list)
+
+
+class Reqif:
+    """Representa un único fichero .reqif (XML, estándar OMG ReqIF).
+
+    Se puede editar el comentario y el estado de cada requisito
+    (`Kommentar Lieferant M` / `Status Lieferant M` por defecto, pero los
+    nombres de atributo son configurables mediante subclase o los
+    parámetros de clase TEXT_ATTR/CHAPTER_ATTR/COMMENT_ATTR/STATUS_ATTR),
+    exportar a Excel con validación de datos para el estado, e importar
+    de vuelta un Excel modificado.
+    """
+
+    TEXT_ATTR = 'ReqIF.Text'
+    CHAPTER_ATTR = 'ReqIF.ChapterName'
+    COMMENT_ATTR = 'Kommentar Lieferant M'
+    STATUS_ATTR = 'Status Lieferant M'
+
+    def __init__(self, source):
+        """source: ruta a un .reqif, o un objeto tipo fichero ya abierto."""
+        if hasattr(source, 'read'):
+            self.path = None
+            self._tree = ET.parse(source)
+        else:
+            self.path = Path(source)
+            self._tree = ET.parse(self.path)
+
+        self._root = self._tree.getroot()
+        self._ns, self._uri = self._namespace()
+        self._definitions = self._build_definitions()
+        self._status_options = self._status_options_list()
+        self._requirements, self._by_id = self._parse_requirements()
+
+    # -- construcción --------------------------------------------------
+
+    def _namespace(self):
+        tag = self._root.tag
+        if '}' in tag:
+            uri = tag.split('}')[0].strip('{')
+            return {'r': uri}, uri
+        return {}, None
+
+    def _qn(self, tag):
+        return f'{{{self._uri}}}{tag}' if self._uri else tag
+
+    def _build_definitions(self):
+        ns = self._ns
+        root = self._root
+        enum_values_by_datatype = {}
+        for dt in root.findall('.//r:DATATYPE-DEFINITION-ENUMERATION', ns):
+            values = [
+                (ev.attrib.get('IDENTIFIER'), ev.attrib.get('LONG-NAME', ''))
+                for ev in dt.findall('.//r:ENUM-VALUE', ns)
+            ]
+            enum_values_by_datatype[dt.attrib.get('IDENTIFIER')] = values
+
+        definitions = {}
+        for tag in _DEFINITION_TAGS:
+            for el in root.findall(f'.//r:{tag}', ns):
+                ident = el.attrib.get('IDENTIFIER')
+                entry = {'long_name': el.attrib.get('LONG-NAME', ''), 'options': []}
+                if tag == 'ATTRIBUTE-DEFINITION-ENUMERATION':
+                    ref = el.find('.//r:DATATYPE-DEFINITION-ENUMERATION-REF', ns)
+                    if ref is not None:
+                        entry['options'] = enum_values_by_datatype.get(ref.text, [])
+                definitions[ident] = entry
+        return definitions
+
+    def _ids_by_name(self, long_name):
+        return {ident for ident, meta in self._definitions.items() if meta['long_name'] == long_name}
+
+    def _status_options_list(self):
+        for ident in self._ids_by_name(self.STATUS_ATTR):
+            return self._definitions[ident]['options']
+        return []
+
+    @staticmethod
+    def _xhtml_text(the_value_el):
+        if the_value_el is None:
+            return ''
+        return ''.join(the_value_el.itertext()).strip()
+
+    @staticmethod
+    def _collect_images(the_value_el):
+        """<object type="image/..." data="ruta"> dentro del XHTML,
+        incluidos los anidados (p.ej. un .doc con una vista previa PNG
+        como fallback)."""
+        if the_value_el is None:
+            return []
+        images = []
+        for obj in the_value_el.iter(f'{{{XHTML_NS}}}object'):
+            obj_type = obj.attrib.get('type', '')
+            data = obj.attrib.get('data')
+            if data and obj_type.startswith('image/'):
+                images.append(data)
+        return images
+
+    def _parse_requirements(self):
+        ns = self._ns
+        text_ids = self._ids_by_name(self.TEXT_ATTR)
+        chapter_ids = self._ids_by_name(self.CHAPTER_ATTR)
+        comment_ids = self._ids_by_name(self.COMMENT_ATTR)
+        status_ids = self._ids_by_name(self.STATUS_ATTR)
+
+        requirements = []
+        by_id = {}
+        for spec_object in self._root.findall('.//r:SPEC-OBJECT', ns):
+            identifier = spec_object.attrib.get('IDENTIFIER', '')
+            values = spec_object.find('r:VALUES', ns)
+            if values is None:
+                continue
+
+            text = ''
+            chapter = ''
+            comment = ''
+            status = ''
+            images = []
+
+            for xhtml_val in values.findall('r:ATTRIBUTE-VALUE-XHTML', ns):
+                ref = xhtml_val.find('.//r:ATTRIBUTE-DEFINITION-XHTML-REF', ns)
+                if ref is None or not ref.text:
+                    continue
+                the_value = xhtml_val.find('r:THE-VALUE', ns)
+                plain = self._xhtml_text(the_value)
+                images.extend(self._collect_images(the_value))
+                if ref.text in text_ids:
+                    text = plain
+                elif ref.text in chapter_ids:
+                    chapter = plain
+                elif ref.text in comment_ids:
+                    comment = plain
+
+            for enum_val in values.findall('r:ATTRIBUTE-VALUE-ENUMERATION', ns):
+                ref = enum_val.find('.//r:ATTRIBUTE-DEFINITION-ENUMERATION-REF', ns)
+                if ref is None or ref.text not in status_ids:
+                    continue
+                enum_ref = enum_val.find('.//r:ENUM-VALUE-REF', ns)
+                if enum_ref is not None:
+                    for opt_id, opt_name in self._status_options:
+                        if opt_id == enum_ref.text:
+                            status = opt_name
+                            break
+
+            requirement = Requirement(
+                id=identifier,
+                text=text or chapter,
+                is_chapter=bool(chapter and not text),
+                comment=comment,
+                status=status,
+                images=images,
+            )
+            requirements.append(requirement)
+            by_id[identifier] = requirement
+
+        return requirements, by_id
+
+    # -- API pública ------------------------------------------------
+
+    @property
+    def requirements(self) -> list[Requirement]:
+        return self._requirements
+
+    @property
+    def status_options(self) -> list[str]:
+        return [name for _opt_id, name in self._status_options]
+
+    def get(self, identifier: str) -> Requirement | None:
+        return self._by_id.get(identifier)
+
+    def __len__(self):
+        return len(self._requirements)
+
+    def __iter__(self):
+        return iter(self._requirements)
+
+    def update(self, identifier: str, comment: str | None = None, status: str | None = None):
+        """Actualiza el comentario y/o el estado de un requisito.
+
+        `None` deja el campo tal cual está; usa '' para vaciarlo.
+        """
+        requirement = self._by_id.get(identifier)
+        if requirement is None:
+            raise ReqifError(f'No se encontró el requisito {identifier}')
+
+        spec_object = self._find_spec_object(identifier)
+        values = spec_object.find('r:VALUES', self._ns)
+        if values is None:
+            values = ET.SubElement(spec_object, self._qn('VALUES'))
+
+        if comment is not None:
+            comment_def_id = next(iter(self._ids_by_name(self.COMMENT_ATTR)), None)
+            if comment_def_id:
+                self._set_xhtml_value(values, comment_def_id, comment)
+            requirement.comment = comment.strip()
+
+        if status is not None:
+            status_def_id = next(iter(self._ids_by_name(self.STATUS_ATTR)), None)
+            if status_def_id:
+                status_ids_by_name = {name: opt_id for opt_id, name in self._status_options}
+                self._set_enumeration_value(values, status_def_id, status, status_ids_by_name)
+            requirement.status = status.strip()
+
+    def update_many(self, updates: Iterable[tuple[str, str | None, str | None]]) -> int:
+        """updates: iterable de (identifier, comment, status). Devuelve
+        cuántas filas coincidieron con un requisito existente."""
+        applied = 0
+        for identifier, comment, status in updates:
+            if identifier not in self._by_id:
+                continue
+            self.update(identifier, comment=comment, status=status)
+            applied += 1
+        return applied
+
+    def _find_spec_object(self, identifier):
+        for candidate in self._root.findall('.//r:SPEC-OBJECT', self._ns):
+            if candidate.attrib.get('IDENTIFIER') == identifier:
+                return candidate
+        raise ReqifError(f'No se encontró el SPEC-OBJECT {identifier}')
+
+    def _set_xhtml_value(self, values, def_id, text):
+        ns = self._ns
+        target = None
+        for xhtml_val in values.findall('r:ATTRIBUTE-VALUE-XHTML', ns):
+            ref = xhtml_val.find('.//r:ATTRIBUTE-DEFINITION-XHTML-REF', ns)
+            if ref is not None and ref.text == def_id:
+                target = xhtml_val
+                break
+
+        text = (text or '').strip()
+
+        if target is None:
+            if not text:
+                return
+            target = ET.SubElement(values, self._qn('ATTRIBUTE-VALUE-XHTML'))
+            definition = ET.SubElement(target, self._qn('DEFINITION'))
+            ref_el = ET.SubElement(definition, self._qn('ATTRIBUTE-DEFINITION-XHTML-REF'))
+            ref_el.text = def_id
+
+        old_value = target.find('r:THE-VALUE', ns)
+        if old_value is not None:
+            target.remove(old_value)
+
+        the_value = ET.SubElement(target, self._qn('THE-VALUE'))
+        div = ET.SubElement(the_value, f'{{{XHTML_NS}}}div')
+        div.text = text
+
+    def _set_enumeration_value(self, values, def_id, status_name, status_ids_by_name):
+        ns = self._ns
+        target = None
+        for enum_val in values.findall('r:ATTRIBUTE-VALUE-ENUMERATION', ns):
+            ref = enum_val.find('.//r:ATTRIBUTE-DEFINITION-ENUMERATION-REF', ns)
+            if ref is not None and ref.text == def_id:
+                target = enum_val
+                break
+
+        enum_id = status_ids_by_name.get((status_name or '').strip())
+
+        if not enum_id:
+            if target is not None:
+                values.remove(target)
+            return
+
+        if target is None:
+            target = ET.SubElement(values, self._qn('ATTRIBUTE-VALUE-ENUMERATION'))
+            definition = ET.SubElement(target, self._qn('DEFINITION'))
+            ref_el = ET.SubElement(definition, self._qn('ATTRIBUTE-DEFINITION-ENUMERATION-REF'))
+            ref_el.text = def_id
+
+        old_values = target.find('r:VALUES', ns)
+        if old_values is not None:
+            target.remove(old_values)
+
+        values_el = ET.SubElement(target, self._qn('VALUES'))
+        ref_val = ET.SubElement(values_el, self._qn('ENUM-VALUE-REF'))
+        ref_val.text = enum_id
+
+    # -- persistencia -------------------------------------------------
+
+    def save(self, destination=None):
+        """Escribe el XML actual en `destination` (ruta u objeto tipo
+        fichero), o en self.path si no se indica ninguno."""
+        target = destination if destination is not None else self.path
+        if target is None:
+            raise ReqifError('No hay ruta de destino: pasa una a save() o crea el Reqif desde una ruta.')
+        self._tree.write(target, encoding='utf-8', xml_declaration=True)
+
+    # -- Excel ----------------------------------------------------------
+
+    def to_excel(self, destination):
+        """Escribe en `destination` (ruta u objeto tipo fichero) un
+        .xlsx con una fila por requisito y un desplegable de validación
+        en la columna de estado con las opciones reales del ReqIF."""
+        option_names = [name for name in self.status_options if name]
+        wrap_top = Alignment(wrap_text=True, vertical='top')
+
+        workbook = Workbook()
+        sheet = workbook.active
+        sheet.title = 'Requisitos'
+        sheet.append(EXCEL_HEADERS)
+        for cell in sheet[1]:
+            cell.alignment = Alignment(wrap_text=True, vertical='center')
+
+        for req in self._requirements:
+            sheet.append([req.id, req.text, req.comment, req.status])
+            row = sheet.max_row
+            for column in ('A', 'B', 'C', 'D'):
+                sheet[f'{column}{row}'].alignment = wrap_top
+
+        sheet.column_dimensions['A'].width = 38
+        sheet.column_dimensions['B'].width = 60
+        sheet.column_dimensions['C'].width = 45
+        sheet.column_dimensions['D'].width = 24
+        sheet.freeze_panes = 'A2'
+
+        if option_names:
+            options_sheet = workbook.create_sheet('Opciones')
+            options_sheet.append([self.STATUS_ATTR])
+            for name in option_names:
+                options_sheet.append([name])
+            options_sheet.sheet_state = 'hidden'
+
+            last_row = len(self._requirements) + 1
+            last_option_row = len(option_names) + 1
+            validation = DataValidation(
+                type='list',
+                formula1=f"=Opciones!$A$2:$A${last_option_row}",
+                allow_blank=True,
+            )
+            sheet.add_data_validation(validation)
+            validation.add(f'D2:D{last_row}')
+
+        workbook.save(destination)
+
+    def update_from_excel(self, source) -> int:
+        """Lee un .xlsx (con las columnas de to_excel) desde `source`
+        (ruta u objeto tipo fichero) y actualiza solo comentario y
+        estado de cada fila, localizando el requisito por su ID
+        (columna A). Devuelve el número de filas aplicadas."""
+        workbook = load_workbook(source, data_only=True)
+        sheet = workbook['Requisitos'] if 'Requisitos' in workbook.sheetnames else workbook.active
+
+        updates = []
+        for row in sheet.iter_rows(min_row=2, values_only=True):
+            if not row or not row[0]:
+                continue
+            identifier = str(row[0]).strip()
+            comment = row[2] if len(row) > 2 and row[2] is not None else ''
+            status = row[3] if len(row) > 3 and row[3] is not None else ''
+            updates.append((identifier, str(comment), str(status)))
+
+        return self.update_many(updates)

pyreqifz-0.1.0/src/pyreqif/reqifz.py

@@ -0,0 +1,96 @@
+"""Reqifz: apertura, edición y reempaquetado de un .reqifz completo."""
+from __future__ import annotations
+
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+
+from .reqif import Reqif
+
+
+class Reqifz:
+    """Un .reqifz es un zip con uno o varios .reqif más los ficheros
+    adjuntos que referencian (imágenes, documentos...). Esta clase lo
+    extrae a un directorio de trabajo, expone cada .reqif como un
+    `Reqif`, y permite reempaquetarlo todo de vuelta conservando los
+    adjuntos intactos.
+
+    Se puede usar como gestor de contexto para limpiar automáticamente
+    el directorio de trabajo cuando este se ha creado internamente:
+
+        with Reqifz("documento.reqifz") as pack:
+            pack.documents[0].update("_abc123", status="akzeptiert")
+            pack.save("documento_editado.reqifz")
+    """
+
+    def __init__(self, source, work_dir: str | Path | None = None):
+        self._owns_work_dir = work_dir is None
+        self.work_dir = Path(work_dir) if work_dir else Path(tempfile.mkdtemp(prefix='pyreqif_'))
+        self.work_dir.mkdir(parents=True, exist_ok=True)
+
+        with zipfile.ZipFile(source) as zf:
+            zf.extractall(self.work_dir)
+
+        self._document_paths = sorted(
+            p.relative_to(self.work_dir) for p in self.work_dir.rglob('*.reqif')
+        )
+        self.documents: list[Reqif] = [Reqif(self.work_dir / p) for p in self._document_paths]
+
+    # -- acceso a los documentos ---------------------------------------
+
+    def get(self, name_or_index) -> Reqif:
+        """Busca un documento por índice, o por nombre (con o sin ruta
+        relativa dentro del zip)."""
+        if isinstance(name_or_index, int):
+            return self.documents[name_or_index]
+        for rel_path, doc in zip(self._document_paths, self.documents):
+            if rel_path.name == name_or_index or str(rel_path) == name_or_index:
+                return doc
+        raise KeyError(name_or_index)
+
+    def __iter__(self):
+        return iter(self.documents)
+
+    def __len__(self):
+        return len(self.documents)
+
+    def document_names(self) -> list[str]:
+        return [p.name for p in self._document_paths]
+
+    # -- adjuntos ------------------------------------------------------
+
+    def image_path(self, image_ref: str) -> Path:
+        """Resuelve una ruta de imagen (tal como aparece en
+        Requirement.images) a una ruta absoluta dentro del directorio
+        de trabajo."""
+        return self.work_dir / image_ref
+
+    def read_image(self, image_ref: str) -> bytes:
+        return self.image_path(image_ref).read_bytes()
+
+    # -- persistencia ----------------------------------------------------
+
+    def save(self, destination):
+        """Vuelca los cambios de cada documento y reempaqueta todo el
+        directorio de trabajo (documentos + adjuntos) en `destination`
+        (ruta u objeto tipo fichero), como .reqifz."""
+        for rel_path, doc in zip(self._document_paths, self.documents):
+            doc.save(self.work_dir / rel_path)
+
+        with zipfile.ZipFile(destination, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for file_path in sorted(self.work_dir.rglob('*')):
+                if file_path.is_file():
+                    zf.write(file_path, file_path.relative_to(self.work_dir))
+
+    def close(self):
+        """Borra el directorio de trabajo, solo si lo creó esta
+        instancia (no si se pasó `work_dir` explícitamente)."""
+        if self._owns_work_dir and self.work_dir.exists():
+            shutil.rmtree(self.work_dir)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()

pyreqifz-0.1.0/src/pyreqifz.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: pyreqifz
+Version: 0.1.0
+Summary: Read, edit and repack ReqIF/ReqIFz requirement documents (OMG ReqIF standard)
+Author: Ernesto Avedillo Carretero
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl>=3.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# pyreqif
+
+Librería Python para leer, editar y reempaquetar documentos [ReqIF](https://www.omg.org/spec/ReqIF/) (`.reqif` / `.reqifz`), el estándar OMG usado habitualmente para intercambiar requisitos entre fabricante y proveedor (p.ej. lastenheft de automoción).
+
+Dos clases:
+
+- **`Reqif`**: un único fichero `.reqif`. Lee cada requisito (`SPEC-OBJECT`) con su texto, y dos campos configurables pensados para el flujo proveedor: comentario (`Kommentar Lieferant M`, XHTML) y estado (`Status Lieferant M`, enumerado). Permite editarlos, exportar/importar por Excel (con desplegable de validación para el estado) y detecta las imágenes embebidas en el texto de cada requisito.
+- **`Reqifz`**: un `.reqifz` (zip con uno o varios `.reqif` más sus adjuntos). Extrae a un directorio de trabajo, expone cada `.reqif` como un `Reqif`, y reempaqueta todo de vuelta conservando los adjuntos intactos.
+
+## Instalación
+
+```bash
+pip install pyreqif
+```
+
+## Uso básico
+
+```python
+from pyreqif import Reqifz
+
+with Reqifz("lastenheft.reqifz") as pack:
+    for doc in pack:
+        print(doc, "->", len(doc), "requisitos")
+
+    doc = pack.get(0)  # o pack.get("nombre_del_fichero.reqif")
+
+    # leer
+    req = doc.get("_a1b2c3...")
+    print(req.text, req.comment, req.status, req.images)
+
+    # editar (None deja el campo igual, "" lo vacía)
+    doc.update("_a1b2c3...", comment="Aceptado, sin cambios.", status="akzeptiert")
+
+    # exportar/importar por Excel
+    doc.to_excel("requisitos.xlsx")
+    doc.update_from_excel("requisitos_revisado.xlsx")
+
+    # volver a empaquetar con los cambios
+    pack.save("lastenheft_editado.reqifz")
+```
+
+Un `.reqif` suelto (sin comprimir) se usa igual, sin pasar por `Reqifz`:
+
+```python
+from pyreqif import Reqif
+
+doc = Reqif("documento.reqif")
+doc.update("_a1b2c3...", status="Klärungsbedarf")
+doc.save("documento_editado.reqif")
+```
+
+## Nombres de atributo
+
+Por defecto se usan los nombres estándar de ReqIF para el texto (`ReqIF.Text` / `ReqIF.ChapterName` como respaldo) y los nombres de campo de este flujo concreto de proveedor (`Kommentar Lieferant M` / `Status Lieferant M`). Si tu documento usa otros nombres, crea una subclase:
+
+```python
+from pyreqif import Reqif
+
+class MiReqif(Reqif):
+    COMMENT_ATTR = "Supplier Comment"
+    STATUS_ATTR = "Supplier Status"
+```
+
+## Desarrollo
+
+```bash
+uv venv
+uv pip install -e ".[dev]"
+uv run pytest
+```
+
+## Licencia
+
+MIT

pyreqifz-0.1.0/src/pyreqifz.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/pyreqif/__init__.py
+src/pyreqif/py.typed
+src/pyreqif/reqif.py
+src/pyreqif/reqifz.py
+src/pyreqifz.egg-info/PKG-INFO
+src/pyreqifz.egg-info/SOURCES.txt
+src/pyreqifz.egg-info/dependency_links.txt
+src/pyreqifz.egg-info/requires.txt
+src/pyreqifz.egg-info/top_level.txt
+tests/test_reqif.py
+tests/test_reqifz.py

pyreqifz-0.1.0/src/pyreqifz.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyreqifz-0.1.0/src/pyreqifz.egg-info/requires.txt

@@ -0,0 +1,6 @@
+openpyxl>=3.1.0
+
+[dev]
+pytest>=8.0
+build>=1.0
+twine>=5.0

pyreqifz-0.1.0/src/pyreqifz.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyreqif

pyreqifz-0.1.0/tests/test_reqif.py

@@ -0,0 +1,119 @@
+from openpyxl import load_workbook
+
+from pyreqif import Reqif, ReqifError
+
+
+def test_parses_requirements_and_chapters(sample_reqif_path):
+    doc = Reqif(sample_reqif_path)
+
+    assert len(doc) == 3
+    chapter = doc.get('_chapter-1')
+    assert chapter.is_chapter is True
+    assert chapter.text == 'Introduccion'
+
+    req1 = doc.get('_req-1')
+    assert 'arrancar en menos de 2 segundos' in req1.text
+    assert req1.images == ['attachments/img1.png']
+
+    req2 = doc.get('_req-2')
+    assert req2.comment == 'Ya validado en pruebas de carga.'
+    assert req2.status == 'akzeptiert'
+
+
+def test_status_options_come_from_the_enumeration_datatype(sample_reqif_path):
+    doc = Reqif(sample_reqif_path)
+    assert doc.status_options == ['akzeptiert', 'Klaerungsbedarf', 'nicht akzeptiert']
+
+
+def test_update_unknown_requirement_raises(sample_reqif_path):
+    doc = Reqif(sample_reqif_path)
+    try:
+        doc.update('_does-not-exist', comment='x')
+        assert False, 'expected ReqifError'
+    except ReqifError:
+        pass
+
+
+def test_update_and_save_roundtrip(sample_reqif_path, tmp_path):
+    doc = Reqif(sample_reqif_path)
+    doc.update('_req-1', comment='Comentario nuevo äöü', status='Klaerungsbedarf')
+
+    out_path = tmp_path / 'edited.reqif'
+    doc.save(out_path)
+
+    reloaded = Reqif(out_path)
+    req1 = reloaded.get('_req-1')
+    assert req1.comment == 'Comentario nuevo äöü'
+    assert req1.status == 'Klaerungsbedarf'
+    # el texto original no se ha tocado
+    assert 'arrancar en menos de 2 segundos' in req1.text
+
+
+def test_update_none_leaves_field_untouched(sample_reqif_path):
+    doc = Reqif(sample_reqif_path)
+    doc.update('_req-2', comment=None, status='nicht akzeptiert')
+
+    req2 = doc.get('_req-2')
+    assert req2.comment == 'Ya validado en pruebas de carga.'
+    assert req2.status == 'nicht akzeptiert'
+
+
+def test_update_empty_string_clears_field(sample_reqif_path):
+    doc = Reqif(sample_reqif_path)
+    doc.update('_req-2', status='')
+
+    req2 = doc.get('_req-2')
+    assert req2.status == ''
+
+
+def test_update_many_returns_count_of_matched_rows(sample_reqif_path):
+    doc = Reqif(sample_reqif_path)
+    applied = doc.update_many([
+        ('_req-1', 'c1', 'akzeptiert'),
+        ('_does-not-exist', 'c2', 'akzeptiert'),
+    ])
+    assert applied == 1
+    assert doc.get('_req-1').comment == 'c1'
+
+
+def test_to_excel_has_data_validation_with_status_options(sample_reqif_path, tmp_path):
+    doc = Reqif(sample_reqif_path)
+    xlsx_path = tmp_path / 'out.xlsx'
+    doc.to_excel(xlsx_path)
+
+    workbook = load_workbook(xlsx_path)
+    assert workbook.sheetnames == ['Requisitos', 'Opciones']
+
+    sheet = workbook['Requisitos']
+    assert [c.value for c in sheet[1]] == ['ID', 'Texto', 'Kommentar Lieferant M', 'Status Lieferant M']
+    assert sheet.max_row == len(doc) + 1
+
+    options = [c[0].value for c in workbook['Opciones'].iter_rows(min_row=2)]
+    assert options == doc.status_options
+
+    validations = list(sheet.data_validations.dataValidation)
+    assert len(validations) == 1
+    assert 'Opciones' in validations[0].formula1
+
+
+def test_update_from_excel_applies_only_comment_and_status(sample_reqif_path, tmp_path):
+    doc = Reqif(sample_reqif_path)
+    xlsx_path = tmp_path / 'roundtrip.xlsx'
+    doc.to_excel(xlsx_path)
+
+    workbook = load_workbook(xlsx_path)
+    sheet = workbook['Requisitos']
+    # fila del _req-1: columna A=ID, C=comentario, D=estado
+    for row in sheet.iter_rows(min_row=2):
+        if row[0].value == '_req-1':
+            row[2].value = 'Actualizado desde Excel'
+            row[3].value = 'nicht akzeptiert'
+    workbook.save(xlsx_path)
+
+    updated = doc.update_from_excel(xlsx_path)
+    assert updated == len(doc)
+
+    req1 = doc.get('_req-1')
+    assert req1.comment == 'Actualizado desde Excel'
+    assert req1.status == 'nicht akzeptiert'
+    assert 'arrancar en menos de 2 segundos' in req1.text

pyreqifz-0.1.0/tests/test_reqifz.py

@@ -0,0 +1,63 @@
+import zipfile
+
+from pyreqif import Reqifz
+
+
+def test_extracts_and_parses_documents(sample_reqifz_path):
+    with Reqifz(sample_reqifz_path) as pack:
+        assert pack.document_names() == ['sample.reqif']
+        assert len(pack) == 1
+
+        doc = pack.get(0)
+        assert len(doc) == 3
+        assert doc.get('_req-2').status == 'akzeptiert'
+
+        # también se puede pedir por nombre de fichero
+        assert pack.get('sample.reqif') is doc
+
+
+def test_image_path_resolves_inside_work_dir(sample_reqifz_path):
+    with Reqifz(sample_reqifz_path) as pack:
+        doc = pack.get(0)
+        req1 = doc.get('_req-1')
+        assert req1.images == ['attachments/img1.png']
+
+        image_path = pack.image_path(req1.images[0])
+        assert image_path.exists()
+        assert image_path.read_bytes().startswith(b'\x89PNG')
+        assert pack.read_image(req1.images[0]).startswith(b'\x89PNG')
+
+
+def test_save_repacks_with_edits_and_keeps_attachments(sample_reqifz_path, tmp_path):
+    with Reqifz(sample_reqifz_path) as pack:
+        doc = pack.get(0)
+        doc.update('_req-1', comment='Revisado por el proveedor', status='akzeptiert')
+
+        out_path = tmp_path / 'edited.reqifz'
+        pack.save(out_path)
+
+    with zipfile.ZipFile(sample_reqifz_path) as zf:
+        original_names = set(zf.namelist())
+    with zipfile.ZipFile(out_path) as zf:
+        edited_names = set(zf.namelist())
+
+    assert original_names == edited_names  # mismos ficheros, nada perdido
+
+    with Reqifz(out_path) as reopened:
+        req1 = reopened.get(0).get('_req-1')
+        assert req1.comment == 'Revisado por el proveedor'
+        assert req1.status == 'akzeptiert'
+
+
+def test_work_dir_is_cleaned_up_when_owned_by_reqifz(sample_reqifz_path):
+    with Reqifz(sample_reqifz_path) as pack:
+        work_dir = pack.work_dir
+        assert work_dir.exists()
+    assert not work_dir.exists()
+
+
+def test_explicit_work_dir_is_not_deleted_on_close(sample_reqifz_path, tmp_path):
+    work_dir = tmp_path / 'kept'
+    with Reqifz(sample_reqifz_path, work_dir=work_dir) as pack:
+        assert pack.work_dir == work_dir
+    assert work_dir.exists()