sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

sysmlpy/library/README.md

@@ -0,0 +1,52 @@
+# SysML v2 Standard Library
+
+This directory contains the normative SysML v2 and KerML standard library files,
+copied verbatim from the **SysML-v2-Pilot-Implementation-2026-03** release.
+
+## Layout
+
+| Directory | Contents |
+|-----------|----------|
+| `kernel/`  | 36 KerML kernel library files (`.kerml`), flattened from `Kernel Libraries/*/` |
+| `systems/` | 21 SysML systems library files (`.sysml`), from `Systems Library/` |
+| `domain/`  | 37 SysML domain library files (`.sysml`), organized by subdirectory |
+
+The `kernel/` and `systems/` directories are intentionally flat (no subdirectory
+nesting), matching the layout used by the `org.omg.sysml.xpect.tests` project in
+the Pilot Implementation.
+
+## Domain Library Subdirectories
+
+```
+domain/
+  Analysis/              AnalysisTooling, SampledFunctions, StateSpaceRepresentation, TradeStudies
+  Cause and Effect/      CausationConnections, CauseAndEffect
+  Geometry/              ShapeItems, SpatialItems
+  Metadata/              ImageMetadata, ModelingMetadata, ParametersOfInterestMetadata, RiskMetadata
+  Quantities and Units/  ISQ, ISQBase, SI, SIPrefixes, ... (22 files)
+  Requirement Derivation/ DerivationConnections, RequirementDerivation
+```
+
+## Purpose
+
+These files are bundled with sysmlpy for two reasons:
+
+1. **Conformance tests** — the test suite under `tests/sysmlv2/` parses files that
+   import from this library (e.g., `private import SI::kg;`). Having the library
+   co-located with the package makes the test suite self-contained.
+
+2. **Future import resolution** — once sysmlpy implements `import` / `AliasMember`
+   support, it can locate these files via:
+   ```python
+   import importlib.resources
+   lib = importlib.resources.files("sysmlpy") / "library"
+   ```
+
+## Source and License
+
+**Source:** [SysML-v2-Pilot-Implementation](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation),
+tag `2026-03`.
+
+**License:** GNU Lesser General Public License v3.0 (see `LICENSE`). The library
+files are copyright © Object Management Group (OMG). sysmlpy itself is MIT-licensed;
+this bundled library content is separately covered by LGPL-3.0.

sysmlpy/library/domain/Analysis/AnalysisTooling.sysml

@@ -0,0 +1,34 @@
+standard library package AnalysisTooling {
+	doc
+	/*
+	 * This package contains definitions for metadata annotations related
+	 * to analysis tool integration.
+	 */
+
+	private import ScalarValues::*;
+	
+	metadata def ToolExecution {
+		doc
+		/*
+		 * ToolExecution metadata identifies an external analysis tool to be
+		 * used to implement the annotated action.
+		 */
+	
+		attribute toolName : String;
+		attribute uri : String;
+	}
+	
+	metadata def ToolVariable {
+		doc
+		/*
+		 * ToolVariable metadata is used in the context of an action that has
+		 * been annotated with ToolExecution metadata. It is used to annotate
+		 * a parameter or other feature of the action with the name of the
+		 * variable in the tool that is to correspond to the annotated
+		 * feature.
+		 */
+	
+		attribute name : String;
+	}
+	
+}

sysmlpy/library/domain/Analysis/SampledFunctions.sysml

@@ -0,0 +1,119 @@
+standard library package SampledFunctions {
+	doc
+	/*
+	 * This package provides a library model of discretely sampled mathematical functions.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::Positive;
+	private import Collections::KeyValuePair;
+	private import Collections::OrderedMap;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::forAll;
+	private import ControlFunctions::collect;
+	private import ControlFunctions::select;
+	
+    attribute def SamplePair :> KeyValuePair {
+		doc
+		/*
+		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
+		 */
+	
+        attribute domainValue :>> key;
+        attribute rangeValue :>> val;
+    }
+
+	attribute def SampledFunction :> OrderedMap {
+		doc
+		/*
+	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, 
+	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
+	     * decreasing.
+	     * 
+	     * It maps discrete domain values to discrete range values.
+	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and 
+	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
+	     */
+	
+		attribute samples: SamplePair[0..*] ordered :>> elements;
+		
+		assert constraint {
+			// Note: Assumes the functions '<' and '>' are defined for the domain type.
+			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing
+            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing
+		}
+	}
+	
+	calc def Domain { 
+		doc
+		/* 
+		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.
+		 */
+		 
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.domainValue;
+	}
+	
+	calc def Range { 
+		doc
+		/* 
+		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.
+		 */
+			
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.rangeValue;
+	}
+	
+	calc def Sample {
+		doc
+		/* 
+		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
+		 */
+		 
+		in calc calculation { in x; }
+		in attribute domainValues [0..*];
+		return sampling = new SampledFunction (
+			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }
+		);
+	}
+	
+	calc def Interpolate {
+		doc
+		/*
+		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
+		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		return attribute result;
+	}
+		
+	calc interpolateLinear : Interpolate {
+		doc
+		/*
+		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		
+		private attribute domainValues = Domain(fn);
+		private attribute index : Positive[0..1] =
+			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
+			
+		private calc def Linear {
+			in attribute lowerSample : SamplePair;
+			in attribute upperSample : SamplePair;
+			in attribute value;
+			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
+			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				
+		}
+		
+		return result [0..1] =
+			if index == null or index == size(domainValues)? null
+			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
+			else Linear(fn.samples#(index+1), fn.samples#(index), value);
+	}
+	
+}

sysmlpy/library/domain/Analysis/StateSpaceRepresentation.sysml

@@ -0,0 +1,143 @@
+standard library package StateSpaceRepresentation {
+	doc
+	/*
+	 * This package provides a model of the foundational state-space system representation, 
+	 * commonly used in control systems.
+	 */
+
+    private import ISQ::DurationValue;
+    private import Quantities::VectorQuantityValue;
+    private import VectorCalculations::*;
+
+    abstract attribute def StateSpace :> VectorQuantityValue;
+    abstract attribute def Input :> VectorQuantityValue;
+    abstract attribute def Output :> VectorQuantityValue;
+
+    abstract calc def GetNextState { 
+    	in input: Input; 
+    	in stateSpace: StateSpace; 
+    	in timeStep: DurationValue; 
+    	return : StateSpace;
+    }
+    abstract calc def GetOutput {
+    	in input: Input; 
+    	in stateSpace: StateSpace;
+    	return : Output;
+	}
+	
+     abstract action def StateSpaceEventDef {
+    	doc
+    	/*
+    	 * Events to be received.
+    	 */
+    }
+    action def ZeroCrossingEventDef :> StateSpaceEventDef;
+
+    item def StateSpaceItem {
+    	doc
+    	/*
+    	 * Item for SSR connection
+    	 */
+    }
+
+    abstract action def StateSpaceDynamics {
+	    doc
+	    /*
+	     * StateSpaceDynamics is the simplest form of State Space Representation,
+	     * and nextState directly computes the stateSpace of the next timestep. 
+	     */
+    
+        in attribute input: Input;
+
+        abstract calc getNextState: GetNextState;
+        abstract calc getOutput: GetOutput;
+        attribute stateSpace: StateSpace;
+
+        out attribute output: Output = getOutput(input, stateSpace);
+    }
+
+    abstract attribute def StateDerivative :> VectorQuantityValue {
+	    doc
+	    /*
+	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
+	     */
+    
+        ref stateSpace: StateSpace;
+        constraint { stateSpace.order == order }
+    }
+
+    abstract calc def GetDerivative {
+	    doc
+	    /*
+	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
+	     */
+	    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateDerivative;
+	}
+	
+    abstract calc def Integrate {
+	    doc
+	    /*
+	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
+	     * Its actual implementation should be given by a solver. 
+	     */
+    
+        in getDerivative: GetDerivative;
+        in input: Input;
+        in initialState: StateSpace;
+        in timeInterval: DurationValue;
+        return result: StateSpace;
+	}
+	
+    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * ContinuousStateSpaceDynamics represents continuous behavior.
+	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
+	     */
+    
+        abstract calc getDerivative: GetDerivative;
+        calc :>> getNextState: GetNextState {
+            /* We compute nextState by Integrate defined above by giving derivative calc. */
+            calc integrate: Integrate {
+                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
+                in input = GetNextState::input;
+                in initialState = GetNextState::stateSpace;
+                in timeInterval = GetNextState::timeStep;
+           }
+           return result = integrate.result;
+        }
+
+        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
+        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ 
+        }
+    }
+
+    abstract calc def GetDifference {
+    	doc
+	    /*
+	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
+	     * where k is the timestep number. 
+	     */
+    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateSpace;
+	}
+	
+    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * DiscreteStateSpaceDynamics represents discrete behavior.
+	     * differences needs to return difference of the stateSpace for each timestep.
+	     */
+    
+        abstract calc getDifference: GetDifference;
+        calc :>> getNextState: GetNextState {
+            attribute diff: StateSpace = getDifference(input, stateSpace);
+            return result = stateSpace + diff;
+        }
+    }
+}

sysmlpy/library/domain/Analysis/TradeStudies.sysml

@@ -0,0 +1,171 @@
+standard library package TradeStudies {
+	doc
+	/*
+	 * This package provides a simple framework for defining trade-off study analysis cases.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import ScalarFunctions::*;
+	private import ControlFunctions::*;
+	
+	abstract calc def EvaluationFunction {
+		doc
+		/*
+		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,
+		 * producing a ScalarValue that can be comparted with the evaluation of other
+		 * alternatives.
+		 */
+	
+		in ref alternative : Anything {
+			doc
+			/*
+			 * The alternative to be evaluated.
+			 */
+		} 
+		
+		return attribute result : ScalarValue[1] {
+			doc
+			/*
+			 * A ScalarValue representing the evaluation of the given alternative.
+			 */
+		} 
+	}
+	
+	abstract requirement def TradeStudyObjective {
+		doc
+		/*
+		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.
+		 * The requirement is to choose from a given set of alternatives the selectedAlternative
+		 * for that has the best evaluation according to a given EvaluationFunction. What
+		 * value is considered "best" is not defined in the abstract base definition but must be
+		 * computed in any concrete specialization.
+		 */
+	
+		subject selectedAlternative : Anything {
+			doc
+			/*
+			 * The alternative that should be selected, as evaluated using the given 
+			 * ObjectiveFunction.
+			 */
+		}
+		
+		in ref alternatives : Anything[1..*] {
+			doc
+			/*
+			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective 
+			 * is the objective.
+			 */
+		}
+		
+		in calc eval : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used in evaluating the given alternatives.
+			 */
+		}
+		
+		attribute best : ScalarValue {
+			doc
+			/*
+			 * Out of the evaluation results of all the given alternatives, the one that is considered 
+			 * "best", in the sense that it is the value the selectedAlternative should have. This 
+			 * value must be computed in any concrete specialization of TradeStudyObjective.
+			 */
+		}
+				
+		require constraint { eval(selectedAlternative) == best }
+	}
+	
+	requirement def MinimizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MinimizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the minimum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+		 
+		attribute :>> best = alternatives->minimize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the minimum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	requirement def MaximizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MaximizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the maximum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+	
+		attribute :>> best = alternatives->maximize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the maximum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	abstract analysis def TradeStudy {
+		doc
+		/*
+		 * A TradeStudy is an analysis case whose subject is a set of alternatives
+		 * (at least one) and whose result is a selection of one of those alternatives.
+		 * The alternatives are evaluated based on a given ObjectiveFunction and the
+		 * selection is made such that it satisfies the objective of the TradeStudy
+		 * (which must be a TradeStudyObjective).
+		 */
+	
+		subject studyAlternatives : Anything[1..*] {
+			doc
+			/*
+			 * The set of alternatives being considered in this TradeStudy. 
+			 * 
+			 * In a TradeStudy usage, bind this feature to the actual collection of
+			 * alternatives to be considered.
+			 */
+		}
+		
+		abstract calc evaluationFunction : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used to evaluate the alternatives.
+			 * 
+			 * In a TradeStudy usage, redefine this feature to provide the desired
+			 * calculation (or bind it to a calculation usage that does so).
+			 */
+		}
+		
+		objective tradeStudyObjective : TradeStudyObjective {
+			doc
+			/*
+			 * The objective of this TradeStudy.
+			 * 
+			 * Redefine this feature to give it a definition that is a concrete
+			 * specialization of TradeStudyObjective. That can either be one of the
+			 * specializations provided in this package, or a more specific user-
+			 * defined one.
+			 */
+		
+            subject :>> selectedAlternative;
+			in ref :>> alternatives = studyAlternatives;
+			in calc :>> eval = evaluationFunction;
+		}
+		
+		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {
+			doc
+			/*
+			 * The alternative selected by this TradeStudy, which is the one that meets the
+			 * requirement of the tradeStudyObjective.
+			 */
+		} tradeStudyObjective(selectedAlternative = a)};
+	}
+	
+}