Trouble when trying to retrieve capella native requirements-related information with P4C

Scripting
1

Dear Capella and Python4Capella users,

I have defined a set of capella native requirements (i.e. without the use of any addon such as Requirements Viewpoint) and I am finding trouble to write a script that effectively extracts requirement-related information, as it seems capella.py does not cover them specifically.

For example, I am trying to retrieve the Requirement Package in which requirements are contained, but differently from other packages which are indeed defined in capella.py (e.g. OperationalCapabilityPkg), the RequirementsPkg is not defined and therefore the following is displayed:

AttributeError: ‘OperationalAnalysis’ object has no attribute ‘get_requirements_pkg’

Indeed, when I retrieve the type of the contents of the model, I have cross-checked that Requirements are typed as EObject (rather than having its own type as for many other model elements such as OperationalActivity, FunctionalExchange
).

Is there any workaround to address this issue and have an easy access to modelled requirements information?

Thanks in advance,
Carlos.

2

Hi Carlos,
May be useful to you, in my case to retrieve the following Requirement
image

I’ve added some lines in capella.py

class Requirement(CapellaElement):

    e_class = get_e_classifier("http://www.polarsys.org/capella/core/requirement/" + capella_version(), "Requirement")
    def __init__(self, java_object = None):
        if java_object is None:
            JavaObject.__init__(self, create_e_object_from_e_classifier(self.e_class))
        elif isinstance(java_object, Requirement):
            JavaObject.__init__(self, java_object.get_java_object())
        elif self.e_class.isInstance(java_object):
            JavaObject.__init__(self, java_object)
        else:
            raise AttributeError("Passed object is not compatible with " + self.__class__.__name__ + ": " + str(java_object))
        
    def get_is_obsolete(self) -> bool:
        """
        Returns: boolean
        """
        return self.get_java_object().getIsObsolete()
    def set_is_obsolte(self, value: bool):
        """
        Returns: boolean
        """
        self.get_java_object().setIsObsolete(value)
    def get_requirement_id(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getRequirementId()
    def set_requirement_id(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setRequirementId(value)

    def get_additional_information(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getAdditionalInformation()
    def set_additional_information(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setAdditionalInformation(value)         
    def get_verification_method(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getVerificationMethod()
    def set_verification_method(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setVerificationMethod(value)  
    def get_verification_phase(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getVerificationPhase()
    def set_verification_phase(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setVerificationPhase(value) 
    def get_implementation_version(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getImplementationVersion()
    def set_implementation_version(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setImplementationVersion(value)        
    def get_feature(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getFeature()
    def set_feature(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setFeature(value) 
        
    def get_related_capella_element(self) -> List[CapellaElement]:

        return create_e_list(self.get_java_object().getRelatedCapellaElements(), CapellaElement)
        
class RequirementsPkg(CapellaElement):

    e_class = get_e_classifier("http://www.polarsys.org/capella/core/requirement/" + capella_version(), "RequirementsPkg")
    def __init__(self, java_object = None):
        if java_object is None:
            JavaObject.__init__(self, create_e_object_from_e_classifier(self.e_class))
        elif isinstance(java_object, RequirementsPkg):
            JavaObject.__init__(self, java_object.get_java_object())
        elif self.e_class.isInstance(java_object):
            JavaObject.__init__(self, java_object)
        else:
            raise AttributeError("Passed object is not compatible with " + self.__class__.__name__ + ": " + str(java_object))
    def get_additional_information(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getAdditionalInformation()
    def set_additional_information(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setAdditionalInformation(value)
    def get_level(self) -> str:
        """
        Returns: string
        """
        return self.get_java_object().getLevel()
    def set_level(self, value: str):
        """
        Returns: string
        """
        self.get_java_object().setLevel(value)

    def get_owned_requirements(self) -> List[Requirement]:

        return create_e_list(self.get_java_object().getOwnedRequirements(), Requirement)
            
    def get_owned_requirement_pkg(self):
        
        return create_e_list(self.get_java_object().getOwnedRequirementPkgs(), RequirementsPkg)

*and then just link with each layer, for example under the class OperationalAnalysis *

    def get_owned_requirement_pkg(self) -> List[RequirementsPkg]:
        """
        Returns: RequirementPkg[*]
        """
        return create_e_list(self.get_java_object().getOwnedRequirementPkgs(), RequirementsPkg)

and finally

include('workspace://Python4Capella/simplified_api/capella.py')
if False:
    from simplified_api.capella import *

aird_path = '/In-Flight Entertainment System/In-Flight Entertainment System.aird'    

model = CapellaModel()
model.open(aird_path)

se = model.get_system_engineering()
req= se.get_operational_analysis()
req_pkg = req.get_all_contents_by_type(RequirementsPkg)

for requirements_pkg in req_pkg:
    print(requirements_pkg.get_name())
    for reqs in requirements_pkg.get_owned_requirements():
        print(reqs.get_name())
        id=reqs.get_requirement_id()
        print(id)
3

Indeed Licia, that worked just fantastic, thank you very for the help! :slight_smile:

1 Like