A port typed `~P` reports its type as `P`: the conjugation is lost in the Symbol, query and reflection APIs and in api-json's PortUsage.type

Abierto
  • ¿Algo no está bien?
#1,962 2 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

@devin-ai-integration ya está trabajando en esto.

Desde el 5/11/2026.

  • #1980 de @devin-ai-integration — abierto

Evaluación

Dificultad
4/5
Tiempo estimado
3-5 días
Aptitud para principiantes
20/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Estancado
Stack tecnológico
go, python
Área
api, backend

Línea de trabajo

Start with the attached repro.py and model, then trace how conjugated port typing is exposed through Symbol, query, reflection, and api-json. The issue cites docs/project/spec-compliance.md and the SysML and KerML requirements; use the reproduction checks to locate the affected paths and verify each reported type. Done when those routes preserve the conjugated definition and the script’s BUG checks pass; linked pull request #1980 is already open.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

bug spec compliance

This issue was written with AI help. The model, the reproduction script and its output are
attached and were run against the version below.

Model and observed behaviour
package ConjugatedPorts {
    port def CmdPort {
        out attribute cmd : ScalarValues::Integer;
    }
    part def Sender {
        port cmdOut : CmdPort;        // ordinary typing
    }
    part def Receiver {
        port cmdIn : ~CmdPort;        // conjugated typing
    }
}

The conjugated port is reported as typed by CmdPort, which makes it indistinguishable from the
ordinary port, in every route a client normally reads:

Route cmdIn : ~CmdPort reports Expected
Python Symbol (metadata['type'], type_facts, specializations) exactly what cmdOut : CmdPort reports: type 'CmdPort', TypeFacts(declared='CmdPort', resolved_id='…::CmdPort'), Specialization(kind='typing', target_id='…::CmdPort'). The ~ is gone even from declared. typing by …::CmdPort::~CmdPort, or at least a conjugation marker; declared='~CmdPort'
model.query type ConjugatedPorts::CmdPort ConjugatedPorts::CmdPort::~CmdPort
Reflection PortUsage::type, ::portDefinition [ConjugatedPorts::CmdPort] [ConjugatedPorts::CmdPort::~CmdPort]
Reflection ownedTyping.conjugatedPortDefinition, ownedTyping.type ExecutionError: reflective feature is not derived: SysML::Systems::ConjugatedPortTyping::conjugatedPortDefinition (same for type) [ConjugatedPorts::CmdPort::~CmdPort]
api-json PortUsage.type [CmdPort] [CmdPort_conjugated], as its own ConjugatedPortTyping.type says

Some parts are already right, which shows the model is built correctly underneath:

  • The reflected ConjugatedPortTyping exists, and its portDefinition is CmdPort.
  • api-json writes the typing as a ConjugatedPortTyping with type = conjugatedPortDefinition =
    CmdPort_conjugated and portDefinition = CmdPort, and writes the PortUsage's portDefinition
    and definition as CmdPort_conjugated. Only PortUsage.type disagrees, and the PortUsage
    carries a private sysx:conjugatedTyping: true flag instead.
  • The conjugated definition is a symbol (model.get("ConjugatedPorts::CmdPort::~CmdPort")), but
    nothing on the port points to it.

The practical effect: a client reading port types (to check interface compatibility, generate
code, or draw diagrams) cannot tell an input-facing ~CmdPort from an output-facing CmdPort.

$ python repro.py          # loads the model with opensysml.loads() over sysml-grpc
[BUG ] cmdIn : ~CmdPort is reported differently from cmdOut : CmdPort
       observed: {'metadata.type': 'CmdPort', 'type_facts': TypeFacts(declared='CmdPort', resolved_id='ConjugatedPorts::CmdPort', resolved_kind='portDef', primitive='', primitive_source='', quantity=False, unit=''), 'specializations': [Specialization(kind='typing', declared='CmdPort', target_id='ConjugatedPorts::CmdPort', target_kind='portDef')]}
[BUG ] query 'type' of cmdIn is the conjugated definition
       observed: 'ConjugatedPorts::CmdPort'
[BUG ] PortUsage::type of cmdIn is the conjugated definition
       observed: ['ConjugatedPorts::CmdPort']
[BUG ] PortUsage::portDefinition of cmdIn is the conjugated definition
       observed: ['ConjugatedPorts::CmdPort']
[OK  ] ConjugatedPortTyping::portDefinition is the original definition
       observed: ['ConjugatedPorts::CmdPort']
[BUG ] ConjugatedPortTyping::conjugatedPortDefinition is the conjugated definition
       observed: ExecutionError('evaluation failed: reflective feature is not derived: SysML::Systems::ConjugatedPortTyping::conjugatedPortDefinition for ')
[BUG ] ConjugatedPortTyping::type is the conjugated definition
       observed: ExecutionError('evaluation failed: reflective feature is not derived: SysML::Systems::ConjugatedPortTyping::type for ')
[INFO] api-json: the port's typing relationship (correct)
       observed: {'@type': 'ConjugatedPortTyping', 'type': {'@id': 'ConjugatedPorts__CmdPort_conjugated'}, 'conjugatedPortDefinition': {'@id': 'ConjugatedPorts__CmdPort_conjugated'}, 'portDefinition': {'@id': 'ConjugatedPorts__CmdPort'}}
[BUG ] api-json: PortUsage.type agrees with its ConjugatedPortTyping.type
       observed: [{'@id': 'ConjugatedPorts__CmdPort'}]
       expected: [{'@id': 'ConjugatedPorts__CmdPort_conjugated'}]
Reproduction files (attached)
File Contents
model.sysml.txt the model above (GitHub does not accept .sysml uploads): rename it to model.sysml next to repro.py
repro.py loads model.sysml with opensysml.loads() and checks the Symbol, query, reflection and api-json routes. Each check prints OK, BUG or INFO, and the script exits 1 while any BUG reproduces.
_common.py shared helper repro.py imports: starts the sysml-grpc named by $OPENSYSML_BINARY, prints the server and client versions, and formats the checks
output.txt the full output of the run reported here

To run it, put _common.py in the parent directory of the folder holding repro.py and
model.sysml, install the client (pip install -e client/python), and point
OPENSYSML_BINARY at a sysml-grpc build:

model.sysml.txt

repro.py

_common.py

output.txt

$ OPENSYSML_BINARY=/path/to/OpenSysML/bin/sysml-grpc python repro.py

Without OPENSYSML_BINARY, _common.py assumes the layout used here: an OpenSysML checkout
next to the directory that holds _common.py, with bin/sysml-grpc built by make build-grpc.

What the specification requires

SysML v2.1 Beta 2, §8.3.12.3 ConjugatedPortTyping:

A ConjugatedPortTyping is a FeatureTyping whose type is a ConjugatedPortDefinition.

conjugatedPortDefinition : ConjugatedPortDefinition {redefines type} — The type of this
ConjugatedPortTyping considered as a FeatureTyping, which must be a ConjugatedPortDefinition.

/portDefinition : PortDefinition — The originalPortDefinition of the conjugatedPortDefinition
of this ConjugatedPortTyping.

So for port cmdIn : ~CmdPort, the typing's type (= conjugatedPortDefinition) is
CmdPort::'~CmdPort', and only the derived portDefinition of the typing is CmdPort.
conjugatedPortDefinition is not a derived property, so "reflective feature is not derived" is
the wrong answer for it in any case.

KerML v1.1 Beta 2, deriveFeatureType: "The types of a Feature are the union of the types of
its typings and the types of the Features it subsets", so cmdIn.type is CmdPort::'~CmdPort'.
PortUsage::portDefinition (the port's definitions) is then that ConjugatedPortDefinition too,
which is what api-json already writes for portDefinition and definition.

The project's compliance record states the same (docs/project/spec-compliance.md,
conjugated-port row, ✅ Faithful): "port p : ~P types a port by the conjugated port definition
P::'~P' (§7.12.3)". The direction reversal that row describes does work. The reported type
does not follow it.

For the Python Symbol facts, which the specification does not define, the natural equivalent
is type_facts.resolved_id / Specialization.target_id = …::CmdPort::~CmdPort (with
declared='~CmdPort'), or an explicit conjugation flag next to the original definition.

Kind of gap

Parsed or resolved into the wrong structure

Reference implementation

Not tried.

Version

sysml-grpc v0.12.0-262-gc86932321 (develop at c86932321), opensysml Python client 0.12.0, Python 3.13.15

Lenguaje dominante
Go
Estrellas
56
Forks
17
Merge medio
12 h 45 min
PR fusionados (30 d)
910

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de Open-MBEE/OpenSysML

Todos los issues de Open-MBEE/OpenSysML

Issues similares

Más issues de Go

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.