sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/systems/VerificationCases.sysml

@@ -0,0 +1,103 @@
+standard library package VerificationCases {
+	doc
+	/*
+	 * This package defines the base types for verification cases and related behavioral elements 
+	 * in the SysML language.
+	 */
+
+	private import Cases::Case;
+	private import Cases::cases;
+	private import Requirements::RequirementCheck;
+	private import ScalarValues::Boolean;
+	
+	abstract verification def VerificationCase :> Case {
+		doc
+		/*
+		 * VerificationCase is the most general class of performances of VerificationCaseDefinitions. 
+		 * VericationCase is the base class of all VerificationCaseDefinitions.
+		 */
+	
+		ref verification self : VerificationCase :>> Case::self;		
+		subject subj :>> Case::subj;
+		return verdict : VerdictKind :>> result;
+		
+		objective obj :>> Case::obj {
+			subject subj = VerificationCase::subj;
+			
+			requirement requirementVerifications : RequirementCheck[0..*] :> subrequirements {
+				doc
+				/*
+				 * A record of the evaluations of the RequirementChecks of requirements being verified.
+				 */
+			}
+		}
+		
+		ref requirement requirementVerifications : RequirementCheck[0..*] = obj.requirementVerifications {
+			doc
+			/*
+			 * Checks on whether the verifiedRequirements of the VerificationCase have been satisfied.
+			 */
+		}
+		
+		abstract verification subVerificationCases : VerificationCase[0..*] :> verificationCases, subcases {
+			doc
+			/*
+			 * The subcases of this VerificationCase that are VerificationCaseUsages.
+			 */
+		}
+		
+	}
+	
+	abstract verification verificationCases : VerificationCase[0..*] nonunique  :> cases {
+		doc
+		/*
+		 * verificationCases is the base feature of all VerificationCaseUsages.
+		 */
+	}
+	
+	enum def VerdictKind {
+		doc
+		/*
+		 * VerdictKind is an enumeration of the possible results of a VerificationCase.
+		 */
+	
+		pass;
+		fail;
+		inconclusive;
+		error;
+	}
+	
+	calc def PassIf {
+		doc
+		/*
+		 * PassIf returns a pass or fail VerdictKind depending on whether its argument is
+		 * true or false.
+		 */
+	
+		in attribute isPassing : Boolean;
+		return attribute verdict : VerdictKind = if isPassing? VerdictKind::pass else VerdictKind::fail;
+	}
+	
+	metadata def VerificationMethod {
+		doc
+		/*
+		 * VerificationMethod can be used as metadata annotating a verification case or action.
+		 */
+	
+		attribute kind : VerificationMethodKind[1..*];
+	}
+	
+	enum def VerificationMethodKind {
+		doc
+		/*
+		 * VerificationMethodKind is an enumeration of the standard methods by which verification
+		 * can be carried out.
+		 */
+	
+		inspect;
+		analyze;
+		demo;
+		test;
+	}
+	
+}

sysmlpy/library/systems/Views.sysml

@@ -0,0 +1,164 @@
+standard library package Views {
+	doc
+	/*
+	 * This package defines the base types for views, viewpoints, renderings and related elements 
+	 * in the SysML language.
+	 */
+
+	private import Parts::Part;
+	private import Parts::parts;
+	private import Requirements::RequirementCheck;
+	private import Requirements::requirementChecks;
+	
+	abstract view def View :> Part {
+		ref view :>> self : View;
+		
+		abstract ref view subviews : View[0..*] :> views {
+    		doc
+    		/*
+    		 * Other Views that are used in the rendering of this View.
+    		 */
+		}
+		
+		abstract ref rendering viewRendering : Rendering[0..1] {
+            doc
+			/*
+			 * The rendering of this View.
+			 */
+		}
+		
+		viewpoint viewpointSatisfactions : ViewpointCheck[0..*] :> viewpointChecks, checkedConstraints {
+            doc
+			/*
+			 * Checks that the View satisfies all required ViewpointUsages.
+			 */
+		}
+		
+		satisfy requirement viewpointConformance by that {
+			doc
+			/*
+			 * An assertion that all viewpointSatisfactions are true.
+			 */
+			 
+			require viewpointSatisfactions {
+				doc
+				/*
+				 * The required ViewpointChecks.
+				 */
+                ref :>> ownedPerformances::this, subperformances::this default that.that;
+			}
+		}
+	}
+	
+	abstract viewpoint def ViewpointCheck :> RequirementCheck {
+		doc
+		/*
+		 * ViewpointCheck is a RequirementCheck for checking if a View meets the concerns of viewpoint stakeholders. 
+		 * It is the base type of all ViewpointDefinitions.
+		 */
+	
+		ref viewpoint :>> self : ViewpointCheck;		
+		subject subj : View[1] :>> RequirementCheck::subj;
+	}
+	
+	abstract rendering def Rendering :> Part {
+		doc
+		/*
+		 * Rendering is the base type of all RenderingDefinitions.
+		 */
+	
+		ref rendering :>> self : Rendering;
+		
+		abstract ref rendering subrenderings : Rendering[0..*] :> renderings {
+			doc
+			/*
+			 * Other Renderings used to carry out this Rendering.
+			 */
+		}
+	}
+	
+	rendering def TextualRendering :> Rendering {
+		doc
+		/*
+		 * A TextualRendering is a Rendering of a View into a textual format.
+		 */
+	}
+
+	rendering def GraphicalRendering :> Rendering {
+		doc
+		/*
+		 * A GraphicalRendering is a Rendering of a View into a Graphical format.
+		 */
+	}
+
+	rendering def TabularRendering :> Rendering {
+		doc
+		/*
+		 * A TabularRendering is a Rendering of a View into a tabular format.
+		 */
+	}
+	
+	abstract view views : View[0..*] nonunique :> parts {
+		doc
+		/*
+		 * views is the base feature of all ViewUsages.
+		 */
+	}
+	
+	abstract viewpoint viewpointChecks : ViewpointCheck[0..*] nonunique :> requirementChecks {
+		doc
+		/*
+		 * viewpointChecks is the base feature of all ViewpointUsages.
+		 */
+	}
+	
+	abstract rendering renderings : Rendering[0..*] nonunique :> parts {
+		doc
+		/*
+		 * renderings is the base feature of all RenderingUsages.
+		 */
+	}
+	
+	rendering asTextualNotation : TextualRendering[1] :> renderings {
+		doc
+		/*
+		 * asTextualNotation renders a View into textual notation as defined in the 
+		 * KerML and SysML specifications.
+		 */
+	}
+	
+	rendering asTreeDiagram : GraphicalRendering[1] :> renderings {
+		doc
+		/*
+		 * asTreeDiagram renders a View as a tree diagram, using the 
+		 * graphical notation defined in the SysML specification.
+		 */
+	}
+	
+	rendering asInterconnectionDiagram : GraphicalRendering[1] :> renderings {
+		doc
+		/*
+		 * asInterconnectionDiagram renders a View as an interconnection 
+		 * diagram, using the graphical notation defined in the SysML specification.
+		 */
+	}
+	
+	rendering asElementTable : TabularRendering[1] :> renderings {
+		doc
+		/*
+		 * asElementTable  renders a View as a table, with one row for each exposed 
+		 * Element and columns rendered by applying the columnViews in order to the
+		 * Element in each row.
+		 */
+	
+		view columnView[0..*] ordered {
+			doc
+			/*
+			 * The Views to be rendered in the column cells, in order, of each rows of the table.
+			 */
+		
+			abstract ref rendering :>> viewRendering[0..1];
+		}
+		rendering :>> subrenderings[0..*] = columnView.viewRendering;
+	}
+}

sysmlpy/navigate.py

@@ -0,0 +1,272 @@
+"""
+sysmlpy.navigate
+~~~~~~~~~~~~~~~~~
+
+Provides the :class:`Searchable` mixin that adds typed property accessors
+and ``find()`` / ``all()`` search methods to :class:`~sysmlpy.definition.Model`,
+:class:`~sysmlpy.definition.Package`, and every
+:class:`~sysmlpy.usage.Usage` subclass.
+
+Usage
+-----
+After parsing, every node in the public-API tree supports::
+
+    model.packages          # direct Package children
+    model.parts             # direct Part children (defs + usages)
+    model.actions           # direct Action children
+
+    model.find('Focus')                    # by name, any depth
+    model.find(type='action')              # by type keyword, any depth
+    model.find('Focus', type='action')     # name + type
+    model.find(type=Action)               # by class
+    model.find('Focus', recursive=False)  # direct children only
+
+    model.all('part')                      # shorthand for find(type='part')
+
+Type strings
+------------
+Each public-API class carries a ``sysml_type`` class attribute:
+
+======================  =============
+Class                   sysml_type
+======================  =============
+Package                 ``'package'``
+Part                    ``'part'``
+Item                    ``'item'``
+Attribute               ``'attribute'``
+Port                    ``'port'``
+Action                  ``'action'``
+State                   ``'state'``
+Constraint              ``'constraint'``
+Calculation             ``'calculation'``
+Requirement             ``'requirement'``
+Connection              ``'connection'``
+Flow                    ``'flow'``
+Enumeration             ``'enumeration'``
+Interface               ``'interface'``
+UseCase                 ``'use_case'``
+Reference               ``'reference'``
+Message                 ``'message'``
+Allocation              ``'allocation'``
+Metadata                ``'metadata'``
+Rendering               ``'rendering'``
+Individual              ``'individual'``
+View                    ``'view'``
+Viewpoint               ``'viewpoint'``
+Concern                 ``'concern'``
+Case                    ``'case'``
+AnalysisCase            ``'analysis'``
+VerificationCase        ``'verification'``
+======================  =============
+"""
+
+
+class Searchable:
+    """Mixin that adds typed property accessors and search helpers.
+
+    Classes that mix this in must expose a ``children`` list whose elements
+    may themselves carry a ``sysml_type`` string attribute (and optionally
+    their own ``find`` method for recursive search).
+    """
+
+    # ------------------------------------------------------------------
+    # Internal helper
+    # ------------------------------------------------------------------
+
+    def _children_of_type(self, *sysml_types):
+        """Return direct children whose ``sysml_type`` is in *sysml_types*."""
+        return [
+            c for c in getattr(self, "children", [])
+            if getattr(c, "sysml_type", None) in sysml_types
+        ]
+
+    # ------------------------------------------------------------------
+    # Typed property accessors (direct children only)
+    # ------------------------------------------------------------------
+
+    @property
+    def packages(self):
+        """Direct :class:`~sysmlpy.definition.Package` children."""
+        return self._children_of_type("package")
+
+    @property
+    def parts(self):
+        """Direct :class:`~sysmlpy.usage.Part` children (definitions and usages)."""
+        return self._children_of_type("part")
+
+    @property
+    def items(self):
+        """Direct :class:`~sysmlpy.usage.Item` children (definitions and usages)."""
+        return self._children_of_type("item")
+
+    @property
+    def attributes(self):
+        """Direct :class:`~sysmlpy.usage.Attribute` children (definitions and usages)."""
+        return self._children_of_type("attribute")
+
+    @property
+    def ports(self):
+        """Direct :class:`~sysmlpy.usage.Port` children (definitions and usages)."""
+        return self._children_of_type("port")
+
+    @property
+    def actions(self):
+        """Direct :class:`~sysmlpy.usage.Action` children (definitions and usages)."""
+        return self._children_of_type("action")
+
+    @property
+    def states(self):
+        """Direct :class:`~sysmlpy.usage.State` children (definitions and usages)."""
+        return self._children_of_type("state")
+
+    @property
+    def constraints(self):
+        """Direct :class:`~sysmlpy.usage.Constraint` children (definitions and usages)."""
+        return self._children_of_type("constraint")
+
+    @property
+    def calculations(self):
+        """Direct :class:`~sysmlpy.usage.Calculation` children (definitions and usages)."""
+        return self._children_of_type("calculation")
+
+    @property
+    def requirements(self):
+        """Direct :class:`~sysmlpy.usage.Requirement` children (definitions and usages)."""
+        return self._children_of_type("requirement")
+
+    @property
+    def connections(self):
+        """Direct :class:`~sysmlpy.usage.Connection` children (definitions and usages)."""
+        return self._children_of_type("connection")
+
+    @property
+    def flows(self):
+        """Direct :class:`~sysmlpy.usage.Flow` children (definitions and usages)."""
+        return self._children_of_type("flow")
+
+    @property
+    def enumerations(self):
+        """Direct :class:`~sysmlpy.usage.Enumeration` children."""
+        return self._children_of_type("enumeration")
+
+    @property
+    def interfaces(self):
+        """Direct :class:`~sysmlpy.usage.Interface` children (definitions and usages)."""
+        return self._children_of_type("interface")
+
+    @property
+    def use_cases(self):
+        """Direct :class:`~sysmlpy.usage.UseCase` children (definitions and usages)."""
+        return self._children_of_type("use_case")
+
+    @property
+    def references(self):
+        """Direct :class:`~sysmlpy.usage.Reference` children."""
+        return self._children_of_type("reference")
+
+    @property
+    def messages(self):
+        """Direct :class:`~sysmlpy.usage.Message` children."""
+        return self._children_of_type("message")
+
+    @property
+    def allocations(self):
+        """Direct :class:`~sysmlpy.usage.Allocation` children (definitions and usages)."""
+        return self._children_of_type("allocation")
+
+    @property
+    def views(self):
+        """Direct :class:`~sysmlpy.usage.View` children (definitions and usages)."""
+        return self._children_of_type("view")
+
+    @property
+    def viewpoints(self):
+        """Direct :class:`~sysmlpy.usage.Viewpoint` children (definitions and usages)."""
+        return self._children_of_type("viewpoint")
+
+    # ------------------------------------------------------------------
+    # Search methods
+    # ------------------------------------------------------------------
+
+    def find(self, name=None, *, type=None, recursive=True):
+        """Find model elements by name and/or SysML type.
+
+        Parameters
+        ----------
+        name : str, optional
+            Declared element name to match exactly.  ``None`` matches any name.
+        type : str or class, optional
+            SysML type to filter by.  Pass a string keyword (``'part'``,
+            ``'action'``, …) or the corresponding class (``Part``,
+            ``Action``, …).  ``None`` matches any type.
+        recursive : bool
+            When ``True`` (default) the search descends recursively into
+            every child that itself exposes a ``find`` method.
+
+        Returns
+        -------
+        list
+            Matching elements.  Returns an empty list when nothing is found.
+
+        Examples
+        --------
+        Find all elements named ``'Focus'`` anywhere in the tree::
+
+            model.find('Focus')
+
+        Find every action, top-level only::
+
+            model.find(type='action', recursive=False)
+
+        Find by class instead of string::
+
+            from sysmlpy import Part
+            model.find(type=Part)
+
+        Combine name and type::
+
+            model.find('engine', type='part')
+        """
+        results = []
+        for child in getattr(self, "children", []):
+            # --- name gate ---
+            if name is not None and getattr(child, "name", None) != name:
+                name_ok = False
+            else:
+                name_ok = True
+
+            # --- type gate ---
+            if type is None:
+                type_ok = True
+            elif isinstance(type, str):
+                type_ok = getattr(child, "sysml_type", None) == type
+            else:
+                type_ok = isinstance(child, type)
+
+            if name_ok and type_ok:
+                results.append(child)
+
+            # --- recurse ---
+            if recursive and hasattr(child, "find"):
+                results.extend(child.find(name=name, type=type, recursive=True))
+
+        return results
+
+    def all(self, type, recursive=True):
+        """Return all elements of *type*, searching recursively by default.
+
+        This is a convenience alias for ``find(type=type, recursive=recursive)``.
+
+        Parameters
+        ----------
+        type : str or class
+            SysML type string (``'part'``, ``'action'``, …) or the
+            corresponding class.
+        recursive : bool
+            When ``True`` (default) the search descends into every child.
+
+        Returns
+        -------
+        list
+        """
+        return self.find(type=type, recursive=recursive)