Skip to content

generic_oscal

trestle.core.generic_oscal ¤

Generic classes to support both SSP and DefinedComponents.

Attributes¤

IMPLEMENTED_REQUIREMENTS = 'implemented_requirements' module-attribute ¤

logger = logging.getLogger(__name__) module-attribute ¤

Classes¤

GenericByComponent ¤

Bases: TrestleBaseModel

Generic ByComponent for SSP and DefinedComponent.

Source code in trestle/core/generic_oscal.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
class GenericByComponent(TrestleBaseModel):
    """Generic ByComponent for SSP and DefinedComponent."""

    # only in SSP
    component_uuid: constr(
        regex=r'^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$'  # noqa FS003
    ) = Field(
        ...,
        alias='component_uuid',
        description='A machine-oriented identifier reference to the component that is implemeting a given control.',
        title='Component Universally Unique Identifier Reference',
    )
    uuid: constr(
        regex=r'^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$'  # noqa FS003
    ) = Field(
        ...,
        description=  # noqa E251
        'A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this by-component entry elsewhere in this or other OSCAL instances. The locally defined UUID of the by-component entry can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',  # noqa E501
        title='By-Component Universally Unique Identifier',
    )
    description: str = Field(
        ...,
        description=  # noqa E251
        'An implementation statement that describes how a control or a control statement is implemented within the referenced system component.',  # noqa E501
        title='Control Implementation Description',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters')
    implementation_status: Optional[common.ImplementationStatus] = Field(None, alias='implementation-status')
    # removed export, inherited, satisfied
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    remarks: Optional[str] = None

    @staticmethod
    def generate() -> GenericByComponent:
        """Generate instance of generic ByComponent."""
        uuid = str(uuid4())
        return GenericByComponent(component_uuid=const.SAMPLE_UUID_STR, uuid=uuid, description='')

    def as_ssp(self) -> ossp.ByComponent:
        """Convert to ssp format."""
        set_params = []
        for set_param in as_list(self.set_parameters):
            new_set_param = ossp.SetParameter(
                param_id=set_param.param_id, values=set_param.values, remarks=set_param.remarks
            )
            set_params.append(new_set_param)
        set_params = none_if_empty(set_params)
        return ossp.ByComponent(
            component_uuid=self.component_uuid,
            uuid=self.uuid,
            description=self.description,
            props=self.props,
            links=self.links,
            set_parameters=set_params,
            implementation_status=self.implementation_status,
            responsible_roles=self.responsible_roles
        )
Attributes¤
component_uuid: constr(regex='^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$') = Field(..., alias='component_uuid', description='A machine-oriented identifier reference to the component that is implemeting a given control.', title='Component Universally Unique Identifier Reference') class-attribute instance-attribute ¤
description: str = Field(..., description='An implementation statement that describes how a control or a control statement is implemented within the referenced system component.', title='Control Implementation Description') class-attribute instance-attribute ¤
implementation_status: Optional[common.ImplementationStatus] = Field(None, alias='implementation-status') class-attribute instance-attribute ¤
props: Optional[List[common.Property]] = Field(None) class-attribute instance-attribute ¤
remarks: Optional[str] = None class-attribute instance-attribute ¤
responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles') class-attribute instance-attribute ¤
set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters') class-attribute instance-attribute ¤
uuid: constr(regex='^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$') = Field(..., description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this by-component entry elsewhere in this or other OSCAL instances. The locally defined UUID of the by-component entry can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.', title='By-Component Universally Unique Identifier') class-attribute instance-attribute ¤
Functions¤
as_ssp() ¤

Convert to ssp format.

Source code in trestle/core/generic_oscal.py 
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def as_ssp(self) -> ossp.ByComponent:
    """Convert to ssp format."""
    set_params = []
    for set_param in as_list(self.set_parameters):
        new_set_param = ossp.SetParameter(
            param_id=set_param.param_id, values=set_param.values, remarks=set_param.remarks
        )
        set_params.append(new_set_param)
    set_params = none_if_empty(set_params)
    return ossp.ByComponent(
        component_uuid=self.component_uuid,
        uuid=self.uuid,
        description=self.description,
        props=self.props,
        links=self.links,
        set_parameters=set_params,
        implementation_status=self.implementation_status,
        responsible_roles=self.responsible_roles
    )
generate() staticmethod ¤

Generate instance of generic ByComponent.

Source code in trestle/core/generic_oscal.py 
71
72
73
74
75
@staticmethod
def generate() -> GenericByComponent:
    """Generate instance of generic ByComponent."""
    uuid = str(uuid4())
    return GenericByComponent(component_uuid=const.SAMPLE_UUID_STR, uuid=uuid, description='')

GenericComponent ¤

Bases: TrestleBaseModel

Generic component for SSP SystemComponent and DefinedComponent.

Source code in trestle/core/generic_oscal.py 
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
class GenericComponent(TrestleBaseModel):
    """Generic component for SSP SystemComponent and DefinedComponent."""

    uuid: constr(
        regex=r'^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$'  # noqa FS003 F722
    ) = Field(
        ...,
        description=  # noqa E251
        'A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this component elsewhere in this or other OSCAL instances. The locally defined UUID of the component can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',  # noqa E501
        title='Component Identifier',
    )
    type: constr(regex=r'^\S(.*\S)?$') = Field(  # noqa A003 F722
        ...,
        description='A category describing the purpose of the component.',
        title='Component Type',
    )
    title: str = Field(
        ...,
        description='A human readable name for the component.',
        title='Component Title',
    )
    description: str = Field(
        ...,
        description='A description of the component, including information about its function.',
        title='Component Description',
    )
    purpose: Optional[str] = Field(
        None,
        description='A summary of the technological or business purpose of the component.',
        title='Purpose',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    protocols: Optional[List[common.Protocol]] = Field(None)
    # ssp does not have a list of ci's but it does have one ci
    control_implementations: Optional[List[GenericControlImplementation]] = Field(None, alias='control-implementations')
    remarks: Optional[str] = None
    # ssp has
    status: common.ImplementationStatus

    def as_defined_component(self) -> comp.DefinedComponent:
        """Convert to DefinedComponent."""
        status = self.status
        class_dict = copy.deepcopy(self.__dict__)
        class_dict.pop('status', None)
        def_comp = comp.DefinedComponent(**class_dict)
        ControlInterface.insert_status_in_props(def_comp, status)
        return def_comp

    @classmethod
    def from_defined_component(cls, def_comp: comp.DefinedComponent) -> GenericComponent:
        """Convert defined component to generic."""
        status = ControlInterface.get_status_from_props(def_comp)
        class_dict = copy.deepcopy(def_comp.__dict__)
        if 'control_implementations' in class_dict:
            new_cis = []
            for ci in class_dict['control_implementations']:
                new_cis.append(GenericControlImplementation.from_component_ci(ci))
            class_dict['control-implementations'] = new_cis
            class_dict.pop('control_implementations', None)
        class_dict['status'] = status
        return cls(**class_dict)

    def as_system_component(self, status_override: str = '') -> ossp.SystemComponent:
        """Convert to SystemComponent."""
        class_dict = copy.deepcopy(self.__dict__)
        class_dict.pop('control_implementations', None)
        status_str = self.status.state if self.status else const.STATUS_OPERATIONAL
        status_str = status_override if status_override else status_str
        if status_str not in ['under-development', 'operational', 'disposition', 'other']:
            logger.warning(
                f'SystemComponent status {status_str} not recognized.  Setting to {const.STATUS_OPERATIONAL}'
            )
            status_str = const.STATUS_OPERATIONAL
        class_dict['status'] = ossp.Status(state=status_str, remarks=self.status.remarks)
        return ossp.SystemComponent(**class_dict)

    @staticmethod
    def generate() -> GenericComponent:
        """Generate instance of GenericComponent."""
        uuid = str(uuid4())
        status = common.ImplementationStatus(state=const.STATUS_OPERATIONAL)
        return GenericComponent(uuid=uuid, type=const.REPLACE_ME, title='', description='', status=status)
Attributes¤
control_implementations: Optional[List[GenericControlImplementation]] = Field(None, alias='control-implementations') class-attribute instance-attribute ¤
description: str = Field(..., description='A description of the component, including information about its function.', title='Component Description') class-attribute instance-attribute ¤
props: Optional[List[common.Property]] = Field(None) class-attribute instance-attribute ¤
protocols: Optional[List[common.Protocol]] = Field(None) class-attribute instance-attribute ¤
purpose: Optional[str] = Field(None, description='A summary of the technological or business purpose of the component.', title='Purpose') class-attribute instance-attribute ¤
remarks: Optional[str] = None class-attribute instance-attribute ¤
responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles') class-attribute instance-attribute ¤
status: common.ImplementationStatus instance-attribute ¤
title: str = Field(..., description='A human readable name for the component.', title='Component Title') class-attribute instance-attribute ¤
type: constr(regex='^\\S(.*\\S)?$') = Field(..., description='A category describing the purpose of the component.', title='Component Type') class-attribute instance-attribute ¤
uuid: constr(regex='^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$') = Field(..., description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this component elsewhere in this or other OSCAL instances. The locally defined UUID of the component can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.', title='Component Identifier') class-attribute instance-attribute ¤
Functions¤
as_defined_component() ¤

Convert to DefinedComponent.

Source code in trestle/core/generic_oscal.py 
191
192
193
194
195
196
197
198
def as_defined_component(self) -> comp.DefinedComponent:
    """Convert to DefinedComponent."""
    status = self.status
    class_dict = copy.deepcopy(self.__dict__)
    class_dict.pop('status', None)
    def_comp = comp.DefinedComponent(**class_dict)
    ControlInterface.insert_status_in_props(def_comp, status)
    return def_comp
as_system_component(status_override='') ¤

Convert to SystemComponent.

Source code in trestle/core/generic_oscal.py 
214
215
216
217
218
219
220
221
222
223
224
225
226
def as_system_component(self, status_override: str = '') -> ossp.SystemComponent:
    """Convert to SystemComponent."""
    class_dict = copy.deepcopy(self.__dict__)
    class_dict.pop('control_implementations', None)
    status_str = self.status.state if self.status else const.STATUS_OPERATIONAL
    status_str = status_override if status_override else status_str
    if status_str not in ['under-development', 'operational', 'disposition', 'other']:
        logger.warning(
            f'SystemComponent status {status_str} not recognized.  Setting to {const.STATUS_OPERATIONAL}'
        )
        status_str = const.STATUS_OPERATIONAL
    class_dict['status'] = ossp.Status(state=status_str, remarks=self.status.remarks)
    return ossp.SystemComponent(**class_dict)
from_defined_component(def_comp) classmethod ¤

Convert defined component to generic.

Source code in trestle/core/generic_oscal.py 
200
201
202
203
204
205
206
207
208
209
210
211
212
@classmethod
def from_defined_component(cls, def_comp: comp.DefinedComponent) -> GenericComponent:
    """Convert defined component to generic."""
    status = ControlInterface.get_status_from_props(def_comp)
    class_dict = copy.deepcopy(def_comp.__dict__)
    if 'control_implementations' in class_dict:
        new_cis = []
        for ci in class_dict['control_implementations']:
            new_cis.append(GenericControlImplementation.from_component_ci(ci))
        class_dict['control-implementations'] = new_cis
        class_dict.pop('control_implementations', None)
    class_dict['status'] = status
    return cls(**class_dict)
generate() staticmethod ¤

Generate instance of GenericComponent.

Source code in trestle/core/generic_oscal.py 
228
229
230
231
232
233
@staticmethod
def generate() -> GenericComponent:
    """Generate instance of GenericComponent."""
    uuid = str(uuid4())
    status = common.ImplementationStatus(state=const.STATUS_OPERATIONAL)
    return GenericComponent(uuid=uuid, type=const.REPLACE_ME, title='', description='', status=status)

GenericControlImplementation ¤

Bases: TrestleBaseModel

Generic control implementation for SSP and CompDef.

Source code in trestle/core/generic_oscal.py 
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
class GenericControlImplementation(TrestleBaseModel):
    """Generic control implementation for SSP and CompDef."""

    # not in ssp
    uuid: constr(
        regex=r'^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$'  # noqa FS003 F722
    ) = Field(
        ...,
        description=  # noqa E251
        'A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference a set of implemented controls elsewhere in this or other OSCAL instances. The locally defined UUID of the control implementation set can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',  # noqa E501
        title='Control Implementation Set Identifier',
    )
    # not in ssp
    source: str = Field(
        ...,
        description=  # noqa E251
        'A reference to an OSCAL catalog or profile providing the referenced control or subcontrol definition.',  # noqa E501
        title='Source Resource Reference',
    )
    description: str = Field(
        ...,
        description=  # noqa E251
        'A description of how the specified set of controls are implemented for the containing component or capability.',  # noqa E501
        title='Control Implementation Description',
    )
    # not in ssp
    props: Optional[List[common.Property]] = Field(None)
    # not in ssp
    links: Optional[List[common.Link]] = Field(None)
    set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters')
    implemented_requirements: List[GenericImplementedRequirement] = Field(..., alias='implemented-requirements')

    @staticmethod
    def generate() -> GenericControlImplementation:
        """Generate instance of this class."""
        uuid = str(uuid4())
        imp_reqs = [GenericImplementedRequirement.generate()]
        class_dict = {
            'uuid': uuid,
            'control-id': const.REPLACE_ME,
            'source': const.REPLACE_ME,
            'description': '',
            'implemented-requirements': imp_reqs
        }
        return GenericControlImplementation(**class_dict)

    @classmethod
    def from_component_ci(cls, control_imp: comp.ControlImplementation) -> GenericControlImplementation:
        """Convert component control imp to generic."""
        class_dict = copy.deepcopy(control_imp.__dict__)
        if IMPLEMENTED_REQUIREMENTS in class_dict:
            new_irs = []
            ir_list = class_dict.get(IMPLEMENTED_REQUIREMENTS, None)
            for ir in as_list(ir_list):
                new_ir = GenericImplementedRequirement.from_comp_def(ir)
                new_irs.append(new_ir)
            class_dict['implemented-requirements'] = none_if_empty(new_irs)
            class_dict.pop(IMPLEMENTED_REQUIREMENTS, None)
            new_sps = []
            sp_list = class_dict.get('set_parameters', None)
            for sp in as_list(sp_list):
                new_sps.append(GenericSetParameter.from_defined_component(sp))
            class_dict['set-parameters'] = none_if_empty(new_sps)
            class_dict.pop('set_parameters', None)

        return cls(**class_dict)

    def as_ssp(self) -> ossp.ControlImplementation:
        """Represent in ssp form."""
        imp_reqs = []
        for imp_req in self.implemented_requirements:
            imp_reqs.append(imp_req.as_ssp())
        class_dict = self.__dict__
        for prop in ['uuid', 'source', 'props', 'links', IMPLEMENTED_REQUIREMENTS]:
            class_dict.pop(prop, None)
        if imp_reqs:
            class_dict['implemented-requirements'] = imp_reqs
            class_dict.pop(IMPLEMENTED_REQUIREMENTS, None)
        return ossp.ControlImplementation(**class_dict)
Attributes¤
description: str = Field(..., description='A description of how the specified set of controls are implemented for the containing component or capability.', title='Control Implementation Description') class-attribute instance-attribute ¤
implemented_requirements: List[GenericImplementedRequirement] = Field(..., alias='implemented-requirements') class-attribute instance-attribute ¤
props: Optional[List[common.Property]] = Field(None) class-attribute instance-attribute ¤
set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters') class-attribute instance-attribute ¤
source: str = Field(..., description='A reference to an OSCAL catalog or profile providing the referenced control or subcontrol definition.', title='Source Resource Reference') class-attribute instance-attribute ¤
uuid: constr(regex='^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$') = Field(..., description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference a set of implemented controls elsewhere in this or other OSCAL instances. The locally defined UUID of the control implementation set can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.', title='Control Implementation Set Identifier') class-attribute instance-attribute ¤
Functions¤
as_ssp() ¤

Represent in ssp form.

Source code in trestle/core/generic_oscal.py 
393
394
395
396
397
398
399
400
401
402
403
404
def as_ssp(self) -> ossp.ControlImplementation:
    """Represent in ssp form."""
    imp_reqs = []
    for imp_req in self.implemented_requirements:
        imp_reqs.append(imp_req.as_ssp())
    class_dict = self.__dict__
    for prop in ['uuid', 'source', 'props', 'links', IMPLEMENTED_REQUIREMENTS]:
        class_dict.pop(prop, None)
    if imp_reqs:
        class_dict['implemented-requirements'] = imp_reqs
        class_dict.pop(IMPLEMENTED_REQUIREMENTS, None)
    return ossp.ControlImplementation(**class_dict)
from_component_ci(control_imp) classmethod ¤

Convert component control imp to generic.

Source code in trestle/core/generic_oscal.py 
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
@classmethod
def from_component_ci(cls, control_imp: comp.ControlImplementation) -> GenericControlImplementation:
    """Convert component control imp to generic."""
    class_dict = copy.deepcopy(control_imp.__dict__)
    if IMPLEMENTED_REQUIREMENTS in class_dict:
        new_irs = []
        ir_list = class_dict.get(IMPLEMENTED_REQUIREMENTS, None)
        for ir in as_list(ir_list):
            new_ir = GenericImplementedRequirement.from_comp_def(ir)
            new_irs.append(new_ir)
        class_dict['implemented-requirements'] = none_if_empty(new_irs)
        class_dict.pop(IMPLEMENTED_REQUIREMENTS, None)
        new_sps = []
        sp_list = class_dict.get('set_parameters', None)
        for sp in as_list(sp_list):
            new_sps.append(GenericSetParameter.from_defined_component(sp))
        class_dict['set-parameters'] = none_if_empty(new_sps)
        class_dict.pop('set_parameters', None)

    return cls(**class_dict)
generate() staticmethod ¤

Generate instance of this class.

Source code in trestle/core/generic_oscal.py 
358
359
360
361
362
363
364
365
366
367
368
369
370
@staticmethod
def generate() -> GenericControlImplementation:
    """Generate instance of this class."""
    uuid = str(uuid4())
    imp_reqs = [GenericImplementedRequirement.generate()]
    class_dict = {
        'uuid': uuid,
        'control-id': const.REPLACE_ME,
        'source': const.REPLACE_ME,
        'description': '',
        'implemented-requirements': imp_reqs
    }
    return GenericControlImplementation(**class_dict)

GenericImplementedRequirement ¤

Bases: TrestleBaseModel

Generic ImplementedRequirement for SSP and DefinedComponent.

Source code in trestle/core/generic_oscal.py 
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
class GenericImplementedRequirement(TrestleBaseModel):
    """Generic ImplementedRequirement for SSP and DefinedComponent."""

    uuid: constr(
        regex=r'^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$'  # noqa FS003 F722
    ) = Field(
        ...,
        description=  # noqa E251
        'A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference a specific control implementation elsewhere in this or other OSCAL instances. The locally defined UUID of the control implementation can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance).This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.',  # noqa E501
        title='Control Implementation Identifier',
    )
    control_id: constr(
        regex=  # noqa E251
        r'^[_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-\.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$'  # noqa E501
    ) = Field(
        ...,
        alias='control-id',
        description=  # noqa E251
        'A human-oriented identifier reference to a control with a corresponding id value. When referencing an externally defined control, the Control Identifier Reference must be used in the context of the external / imported OSCAL instance (e.g., uri-reference).',  # noqa E501
        title='Control Identifier Reference',
    )
    # only compdef has description
    description: str = Field(
        ...,
        description=  # noqa E251
        'A description of how the specified control is implemented for the containing component or capability.',  # noqa E501
        title='Control Implementation Description',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters')
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    statements: Optional[List[GenericStatement]] = Field(None)
    remarks: Optional[str] = None
    # ssp has following
    by_components: Optional[List[GenericByComponent]] = Field(None, alias='by-components')

    @staticmethod
    def generate() -> GenericImplementedRequirement:
        """Generate instance of this class."""
        uuid = str(uuid4())
        class_dict = {'uuid': uuid, 'control-id': const.REPLACE_ME, 'description': ''}
        return GenericImplementedRequirement(**class_dict)

    @classmethod
    def from_comp_def(cls, imp_req: comp.ImplementedRequirement) -> GenericImplementedRequirement:
        """Convert component form of imp req to generic."""
        class_dict = copy.deepcopy(imp_req.__dict__)
        class_dict['control-id'] = class_dict.pop('control_id', None)
        return cls(**class_dict)

    def as_ssp(self) -> ossp.ImplementedRequirement:
        """Convert to ssp form."""
        class_dict = copy.deepcopy(self.__dict__)
        del class_dict['description']
        new_stat_list = []
        for statement in as_list(self.statements):
            new_stat_list.append(statement.as_ssp())
        if new_stat_list:
            class_dict['statements'] = new_stat_list
        return ossp.ImplementedRequirement(**class_dict)
Attributes¤
by_components: Optional[List[GenericByComponent]] = Field(None, alias='by-components') class-attribute instance-attribute ¤
control_id: constr(regex='^[_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-\\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$') = Field(..., alias='control-id', description='A human-oriented identifier reference to a control with a corresponding id value. When referencing an externally defined control, the Control Identifier Reference must be used in the context of the external / imported OSCAL instance (e.g., uri-reference).', title='Control Identifier Reference') class-attribute instance-attribute ¤
description: str = Field(..., description='A description of how the specified control is implemented for the containing component or capability.', title='Control Implementation Description') class-attribute instance-attribute ¤
props: Optional[List[common.Property]] = Field(None) class-attribute instance-attribute ¤
remarks: Optional[str] = None class-attribute instance-attribute ¤
responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles') class-attribute instance-attribute ¤
set_parameters: Optional[List[GenericSetParameter]] = Field(None, alias='set-parameters') class-attribute instance-attribute ¤
statements: Optional[List[GenericStatement]] = Field(None) class-attribute instance-attribute ¤
uuid: constr(regex='^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$') = Field(..., description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference a specific control implementation elsewhere in this or other OSCAL instances. The locally defined UUID of the control implementation can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance).This UUID should be assigned per-subject, which means it should be consistently used to identify the same subject across revisions of the document.', title='Control Implementation Identifier') class-attribute instance-attribute ¤
Functions¤
as_ssp() ¤

Convert to ssp form.

Source code in trestle/core/generic_oscal.py 
314
315
316
317
318
319
320
321
322
323
def as_ssp(self) -> ossp.ImplementedRequirement:
    """Convert to ssp form."""
    class_dict = copy.deepcopy(self.__dict__)
    del class_dict['description']
    new_stat_list = []
    for statement in as_list(self.statements):
        new_stat_list.append(statement.as_ssp())
    if new_stat_list:
        class_dict['statements'] = new_stat_list
    return ossp.ImplementedRequirement(**class_dict)
from_comp_def(imp_req) classmethod ¤

Convert component form of imp req to generic.

Source code in trestle/core/generic_oscal.py 
307
308
309
310
311
312
@classmethod
def from_comp_def(cls, imp_req: comp.ImplementedRequirement) -> GenericImplementedRequirement:
    """Convert component form of imp req to generic."""
    class_dict = copy.deepcopy(imp_req.__dict__)
    class_dict['control-id'] = class_dict.pop('control_id', None)
    return cls(**class_dict)
generate() staticmethod ¤

Generate instance of this class.

Source code in trestle/core/generic_oscal.py 
300
301
302
303
304
305
@staticmethod
def generate() -> GenericImplementedRequirement:
    """Generate instance of this class."""
    uuid = str(uuid4())
    class_dict = {'uuid': uuid, 'control-id': const.REPLACE_ME, 'description': ''}
    return GenericImplementedRequirement(**class_dict)

GenericSetParameter ¤

Bases: TrestleBaseModel

Generic SetParameter for SSP and DefinedComponent.

Source code in trestle/core/generic_oscal.py 
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
class GenericSetParameter(TrestleBaseModel):
    """Generic SetParameter for SSP and DefinedComponent."""

    param_id: constr(
        regex=  # noqa E251
        r'^[_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-\.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$'  # noqa E501
    ) = Field(
        ...,
        alias='param-id',
        description=  # noqa E251
        "A human-oriented reference to a parameter within a control, who's catalog has been imported into the current implementation context.",  # noqa E501
        title='Parameter ID',
    )
    values: List[str] = Field(...)
    remarks: Optional[str] = None

    @staticmethod
    def from_defined_component(sp: comp.SetParameter):
        """Generate generic set parameter from comp_def version."""
        class_dict = {'param-id': sp.param_id, 'values': sp.values, 'remarks': sp.remarks}
        return GenericSetParameter(**class_dict)

    def to_ssp(self):
        """Convert to ssp format."""
        return (ossp.SetParameter(param_id=self.param_id, values=self.values, remarks=self.remarks))
Attributes¤
param_id: constr(regex='^[_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-\\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$') = Field(..., alias='param-id', description="A human-oriented reference to a parameter within a control, who's catalog has been imported into the current implementation context.", title='Parameter ID') class-attribute instance-attribute ¤
remarks: Optional[str] = None class-attribute instance-attribute ¤
values: List[str] = Field(...) class-attribute instance-attribute ¤
Functions¤
from_defined_component(sp) staticmethod ¤

Generate generic set parameter from comp_def version.

Source code in trestle/core/generic_oscal.py 
252
253
254
255
256
@staticmethod
def from_defined_component(sp: comp.SetParameter):
    """Generate generic set parameter from comp_def version."""
    class_dict = {'param-id': sp.param_id, 'values': sp.values, 'remarks': sp.remarks}
    return GenericSetParameter(**class_dict)
to_ssp() ¤

Convert to ssp format.

Source code in trestle/core/generic_oscal.py 
258
259
260
def to_ssp(self):
    """Convert to ssp format."""
    return (ossp.SetParameter(param_id=self.param_id, values=self.values, remarks=self.remarks))

GenericStatement ¤

Bases: TrestleBaseModel

Generic statement for SSP and DefinedComp.

Source code in trestle/core/generic_oscal.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
class GenericStatement(TrestleBaseModel):
    """Generic statement for SSP and DefinedComp."""

    statement_id: constr(
        regex=  # noqa E251
        r'^[_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-\.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$'  # noqa FS003 E501
    ) = Field(
        ...,
        alias='statement_id',
        description='A human-oriented identifier reference to a control statement.',
        title='Control Statement Reference',
    )
    uuid: constr(
        regex=r'^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$'  # noqa FS003 F722
    ) = Field(
        ...,
        description=  # noqa E251
        'A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this control statement elsewhere in this or other OSCAL instances. The UUID of the control statement in the source OSCAL instance is sufficient to reference the data item locally or globally (e.g., in an imported OSCAL instance).',  # noqa E501
        title='Control Statement Reference Universally Unique Identifier',
    )
    # this is not in ssp statement
    description: str = Field(
        ...,
        description='A summary of how the containing control statement is implemented by the component or capability.',
        title='Statement Implementation Description',
    )
    props: Optional[List[common.Property]] = Field(None)
    links: Optional[List[common.Link]] = Field(None)
    responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles')
    remarks: Optional[str] = None
    # ssp has following
    by_components: Optional[List[GenericByComponent]] = Field(None, alias='by-components')

    def as_ssp(self) -> ossp.Statement:
        """Represent in ssp form."""
        class_dict = copy.deepcopy(self.__dict__)
        class_dict.pop('description', None)
        by_comps = []
        for by_comp in as_list(self.by_components):
            new_by_comp = by_comp.as_ssp()
            by_comps.append(new_by_comp)
        return ossp.Statement(
            statement_id=self.statement_id,
            uuid=self.uuid,
            props=self.props,
            links=self.links,
            responsible_roles=self.responsible_roles,
            by_components=by_comps,
            remarks=self.remarks
        )
Attributes¤
by_components: Optional[List[GenericByComponent]] = Field(None, alias='by-components') class-attribute instance-attribute ¤
description: str = Field(..., description='A summary of how the containing control statement is implemented by the component or capability.', title='Statement Implementation Description') class-attribute instance-attribute ¤
props: Optional[List[common.Property]] = Field(None) class-attribute instance-attribute ¤
remarks: Optional[str] = None class-attribute instance-attribute ¤
responsible_roles: Optional[List[common.ResponsibleRole]] = Field(None, alias='responsible-roles') class-attribute instance-attribute ¤
statement_id: constr(regex='^[_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-\\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$') = Field(..., alias='statement_id', description='A human-oriented identifier reference to a control statement.', title='Control Statement Reference') class-attribute instance-attribute ¤
uuid: constr(regex='^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-4[0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$') = Field(..., description='A machine-oriented, globally unique identifier with cross-instance scope that can be used to reference this control statement elsewhere in this or other OSCAL instances. The UUID of the control statement in the source OSCAL instance is sufficient to reference the data item locally or globally (e.g., in an imported OSCAL instance).', title='Control Statement Reference Universally Unique Identifier') class-attribute instance-attribute ¤
Functions¤
as_ssp() ¤

Represent in ssp form.

Source code in trestle/core/generic_oscal.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def as_ssp(self) -> ossp.Statement:
    """Represent in ssp form."""
    class_dict = copy.deepcopy(self.__dict__)
    class_dict.pop('description', None)
    by_comps = []
    for by_comp in as_list(self.by_components):
        new_by_comp = by_comp.as_ssp()
        by_comps.append(new_by_comp)
    return ossp.Statement(
        statement_id=self.statement_id,
        uuid=self.uuid,
        props=self.props,
        links=self.links,
        responsible_roles=self.responsible_roles,
        by_components=by_comps,
        remarks=self.remarks
    )

Functions¤

handler: python