# cyclonedx.model.lifecycle

> This set of classes represents the lifecycles types in the CycloneDX standard.

Note

Introduced in CycloneDX v1.5

Note

See the CycloneDX Schema for lifecycles: https://cyclonedx.org/docs/1.7/xml/#metadata_lifecycles

## Attributes

`Lifecycle` | TypeAlias for a union of supported lifecycle models.

## Classes

`LifecyclePhase` | Enum object that defines the permissible 'phase' for a Lifecycle according to the CycloneDX schema.
`PredefinedLifecycle` | Object that defines pre-defined phases in the product lifecycle.
`NamedLifecycle` | Object that defines custom state in the product lifecycle.
`LifecycleRepository` | Collection of `Lifecycle`.

## Module Contents

class cyclonedx.model.lifecycle.LifecyclePhase

  Bases: `str`, `enum.Enum`

  Enum object that defines the permissible ‘phase’ for a Lifecycle according to the CycloneDX schema.

  Note

  See the CycloneDX Schema definition: https://cyclonedx.org/docs/1.7/xml/#type_classification

  DESIGN = 'design'
  PRE_BUILD = 'pre-build'
  BUILD = 'build'
  POST_BUILD = 'post-build'
  OPERATIONS = 'operations'
  DISCOVERY = 'discovery'
  DECOMMISSION = 'decommission'

class cyclonedx.model.lifecycle.PredefinedLifecycle(phase: LifecyclePhase)

  Object that defines pre-defined phases in the product lifecycle.

  Note

  See the CycloneDX Schema definition: https://cyclonedx.org/docs/1.7/json/#tab-pane_metadata_lifecycles_items_oneOf_i0

  property phase: LifecyclePhase

class cyclonedx.model.lifecycle.NamedLifecycle(name: str, *, description: str | None = None)

  Object that defines custom state in the product lifecycle.

  Note

  See the CycloneDX Schema definition: https://cyclonedx.org/docs/1.7/json/#tab-pane_metadata_lifecycles_items_oneOf_i1

  property name: str

    Name of the lifecycle phase.

    Returns:

      str

  property description: str | None

    Description of the lifecycle phase.

    Returns:

      str

cyclonedx.model.lifecycle.Lifecycle

  TypeAlias for a union of supported lifecycle models.

  - `PredefinedLifecycle`

  - `NamedLifecycle`

class cyclonedx.model.lifecycle.LifecycleRepository(iterable=None, key=None)

  Bases: `sortedcontainers.SortedSet`[`Lifecycle`]

  Collection of `Lifecycle`.

  This is a set, not a list. Order MUST NOT matter here.

  isdisjoint

    Return True if two sets have a null intersection.

  issubset
  issuperset
  bisect_left
  bisect
  bisect_right
  index

    S.index(value, [start, [stop]]) -> integer – return first index of value. Raises ValueError if the value is not present.

    Supporting start and stop arguments is optional, but recommended.

  irange
  islice
  property key

    Function used to extract comparison key from values.

    Sorted set compares values directly when the key function is none.

  add(value)

    Add value to sorted set.

    Runtime complexity: O(log(n)) – approximate.

        >>> ss = SortedSet()
        >>> ss.add(3)
        >>> ss.add(1)
        >>> ss.add(2)
        >>> ss
        SortedSet([1, 2, 3])

    Parameters:

      value – value to add to sorted set

  clear()

    Remove all values from sorted set.

    Runtime complexity: O(n)

  copy()

    Return a shallow copy of the sorted set.

    Runtime complexity: O(n)

    Returns:

      new sorted set

  count(value)

    Return number of occurrences of value in the sorted set.

    Runtime complexity: O(1)

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.count(3)
        1

    Parameters:

      value – value to count in sorted set

    Returns:

      count

  discard(value)

    Remove value from sorted set if it is a member.

    If value is not a member, do nothing.

    Runtime complexity: O(log(n)) – approximate.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.discard(5)
        >>> ss.discard(0)
        >>> ss == set([1, 2, 3, 4])
        True

    Parameters:

      value – value to discard from sorted set

  pop(index=-1)

    Remove and return value at index in sorted set.

    Raise `IndexError` if the sorted set is empty or index is out of range.

    Negative indices are supported.

    Runtime complexity: O(log(n)) – approximate.

        >>> ss = SortedSet('abcde')
        >>> ss.pop()
        'e'
        >>> ss.pop(2)
        'c'
        >>> ss
        SortedSet(['a', 'b', 'd'])

    Parameters:

      index (int) – index of value (default -1)

    Returns:

      value

    Raises:

      IndexError – if index is out of range

  remove(value)

    Remove value from sorted set; value must be a member.

    If value is not a member, raise `KeyError`.

    Runtime complexity: O(log(n)) – approximate.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.remove(5)
        >>> ss == set([1, 2, 3, 4])
        True
        >>> ss.remove(0)
        Traceback (most recent call last):
          ...
        KeyError: 0

    Parameters:

      value – value to remove from sorted set

    Raises:

      KeyError – if value is not in sorted set

  difference(*iterables)

    Return the difference of two or more sets as a new sorted set.

    The difference method also corresponds to operator `-`.

    `ss.__sub__(iterable)` <==> `ss - iterable`

    The difference is all values that are in this sorted set but not the other iterables.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.difference([4, 5, 6, 7])
        SortedSet([1, 2, 3])

    Parameters:

      iterables – iterable arguments

    Returns:

      new sorted set

  difference_update(*iterables)

    Remove all values of iterables from this sorted set.

    The difference_update method also corresponds to operator `-=`.

    `ss.__isub__(iterable)` <==> `ss -= iterable`

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> _ = ss.difference_update([4, 5, 6, 7])
        >>> ss
        SortedSet([1, 2, 3])

    Parameters:

      iterables – iterable arguments

    Returns:

      itself

  intersection(*iterables)

    Return the intersection of two or more sets as a new sorted set.

    The intersection method also corresponds to operator `&`.

    `ss.__and__(iterable)` <==> `ss & iterable`

    The intersection is all values that are in this sorted set and each of the other iterables.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.intersection([4, 5, 6, 7])
        SortedSet([4, 5])

    Parameters:

      iterables – iterable arguments

    Returns:

      new sorted set

  intersection_update(*iterables)

    Update the sorted set with the intersection of iterables.

    The intersection_update method also corresponds to operator `&=`.

    `ss.__iand__(iterable)` <==> `ss &= iterable`

    Keep only values found in itself and all iterables.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> _ = ss.intersection_update([4, 5, 6, 7])
        >>> ss
        SortedSet([4, 5])

    Parameters:

      iterables – iterable arguments

    Returns:

      itself

  symmetric_difference(other)

    Return the symmetric difference with other as a new sorted set.

    The symmetric_difference method also corresponds to operator `^`.

    `ss.__xor__(other)` <==> `ss ^ other`

    The symmetric difference is all values tha are in exactly one of the sets.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.symmetric_difference([4, 5, 6, 7])
        SortedSet([1, 2, 3, 6, 7])

    Parameters:

      other – other iterable

    Returns:

      new sorted set

  symmetric_difference_update(other)

    Update the sorted set with the symmetric difference with other.

    The symmetric_difference_update method also corresponds to operator `^=`.

    `ss.__ixor__(other)` <==> `ss ^= other`

    Keep only values found in exactly one of itself and other.

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> _ = ss.symmetric_difference_update([4, 5, 6, 7])
        >>> ss
        SortedSet([1, 2, 3, 6, 7])

    Parameters:

      other – other iterable

    Returns:

      itself

  union(*iterables)

    Return new sorted set with values from itself and all iterables.

    The union method also corresponds to operator `|`.

    `ss.__or__(iterable)` <==> `ss | iterable`

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> ss.union([4, 5, 6, 7])
        SortedSet([1, 2, 3, 4, 5, 6, 7])

    Parameters:

      iterables – iterable arguments

    Returns:

      new sorted set

  update(*iterables)

    Update the sorted set adding values from all iterables.

    The update method also corresponds to operator `|=`.

    `ss.__ior__(iterable)` <==> `ss |= iterable`

        >>> ss = SortedSet([1, 2, 3, 4, 5])
        >>> _ = ss.update([4, 5, 6, 7])
        >>> ss
        SortedSet([1, 2, 3, 4, 5, 6, 7])

    Parameters:

      iterables – iterable arguments

    Returns:

      itself