:doc:`Rekognition <../../rekognition>` / Client / get_content_moderation

**********************
get_content_moderation
**********************



.. py:method:: Rekognition.Client.get_content_moderation(**kwargs)

  

  Gets the inappropriate, unwanted, or offensive content analysis results for a Amazon Rekognition Video analysis started by  StartContentModeration. For a list of moderation labels in Amazon Rekognition, see `Using the image and video moderation APIs <https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api>`__.

   

  Amazon Rekognition Video inappropriate or offensive content detection in a stored video is an asynchronous operation. You start analysis by calling  StartContentModeration which returns a job identifier ( ``JobId``). When analysis finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service topic registered in the initial call to ``StartContentModeration``. To get the results of the content analysis, first check that the status value published to the Amazon SNS topic is ``SUCCEEDED``. If so, call ``GetContentModeration`` and pass the job identifier ( ``JobId``) from the initial call to ``StartContentModeration``.

   

  For more information, see Working with Stored Videos in the Amazon Rekognition Devlopers Guide.

   

  ``GetContentModeration`` returns detected inappropriate, unwanted, or offensive content moderation labels, and the time they are detected, in an array, ``ModerationLabels``, of  ContentModerationDetection objects.

   

  By default, the moderated labels are returned sorted by time, in milliseconds from the start of the video. You can also sort them by moderated label by specifying ``NAME`` for the ``SortBy`` input parameter.

   

  Since video analysis can return a large number of results, use the ``MaxResults`` parameter to limit the number of labels returned in a single call to ``GetContentModeration``. If there are more results than specified in ``MaxResults``, the value of ``NextToken`` in the operation response contains a pagination token for getting the next set of results. To get the next page of results, call ``GetContentModeration`` and populate the ``NextToken`` request parameter with the value of ``NextToken`` returned from the previous call to ``GetContentModeration``.

   

  For more information, see moderating content in the Amazon Rekognition Developer Guide.

  

  See also: `AWS API Documentation <https://docs.aws.amazon.com/goto/WebAPI/rekognition-2016-06-27/GetContentModeration>`_  


  **Request Syntax**
  ::

    response = client.get_content_moderation(
        JobId='string',
        MaxResults=123,
        NextToken='string',
        SortBy='NAME'|'TIMESTAMP',
        AggregateBy='TIMESTAMPS'|'SEGMENTS'
    )
    
  :type JobId: string
  :param JobId: **[REQUIRED]** 

    The identifier for the inappropriate, unwanted, or offensive content moderation job. Use ``JobId`` to identify the job in a subsequent call to ``GetContentModeration``.

    

  
  :type MaxResults: integer
  :param MaxResults: 

    Maximum number of results to return per paginated call. The largest value you can specify is 1000. If you specify a value greater than 1000, a maximum of 1000 results is returned. The default value is 1000.

    

  
  :type NextToken: string
  :param NextToken: 

    If the previous response was incomplete (because there is more data to retrieve), Amazon Rekognition returns a pagination token in the response. You can use this pagination token to retrieve the next set of content moderation labels.

    

  
  :type SortBy: string
  :param SortBy: 

    Sort to use for elements in the ``ModerationLabelDetections`` array. Use ``TIMESTAMP`` to sort array elements by the time labels are detected. Use ``NAME`` to alphabetically group elements for a label together. Within each label group, the array element are sorted by detection confidence. The default sort is by ``TIMESTAMP``.

    

  
  :type AggregateBy: string
  :param AggregateBy: 

    Defines how to aggregate results of the StartContentModeration request. Default aggregation option is TIMESTAMPS. SEGMENTS mode aggregates moderation labels over time.

    

  
  
  :rtype: dict
  :returns: 
    
    **Response Syntax**

    
    ::

      {
          'JobStatus': 'IN_PROGRESS'|'SUCCEEDED'|'FAILED',
          'StatusMessage': 'string',
          'VideoMetadata': {
              'Codec': 'string',
              'DurationMillis': 123,
              'Format': 'string',
              'FrameRate': ...,
              'FrameHeight': 123,
              'FrameWidth': 123,
              'ColorRange': 'FULL'|'LIMITED'
          },
          'ModerationLabels': [
              {
                  'Timestamp': 123,
                  'ModerationLabel': {
                      'Confidence': ...,
                      'Name': 'string',
                      'ParentName': 'string',
                      'TaxonomyLevel': 123
                  },
                  'StartTimestampMillis': 123,
                  'EndTimestampMillis': 123,
                  'DurationMillis': 123,
                  'ContentTypes': [
                      {
                          'Confidence': ...,
                          'Name': 'string'
                      },
                  ]
              },
          ],
          'NextToken': 'string',
          'ModerationModelVersion': 'string',
          'JobId': 'string',
          'Video': {
              'S3Object': {
                  'Bucket': 'string',
                  'Name': 'string',
                  'Version': 'string'
              }
          },
          'JobTag': 'string',
          'GetRequestMetadata': {
              'SortBy': 'NAME'|'TIMESTAMP',
              'AggregateBy': 'TIMESTAMPS'|'SEGMENTS'
          }
      }
      
    **Response Structure**

    

    - *(dict) --* 
      

      - **JobStatus** *(string) --* 

        The current status of the content moderation analysis job.

        
      

      - **StatusMessage** *(string) --* 

        If the job fails, ``StatusMessage`` provides a descriptive error message.

        
      

      - **VideoMetadata** *(dict) --* 

        Information about a video that Amazon Rekognition analyzed. ``Videometadata`` is returned in every page of paginated responses from ``GetContentModeration``.

        
        

        - **Codec** *(string) --* 

          Type of compression used in the analyzed video.

          
        

        - **DurationMillis** *(integer) --* 

          Length of the video in milliseconds.

          
        

        - **Format** *(string) --* 

          Format of the analyzed video. Possible values are MP4, MOV and AVI.

          
        

        - **FrameRate** *(float) --* 

          Number of frames per second in the video.

          
        

        - **FrameHeight** *(integer) --* 

          Vertical pixel dimension of the video.

          
        

        - **FrameWidth** *(integer) --* 

          Horizontal pixel dimension of the video.

          
        

        - **ColorRange** *(string) --* 

          A description of the range of luminance values in a video, either LIMITED (16 to 235) or FULL (0 to 255).

          
    
      

      - **ModerationLabels** *(list) --* 

        The detected inappropriate, unwanted, or offensive content moderation labels and the time(s) they were detected.

        
        

        - *(dict) --* 

          Information about an inappropriate, unwanted, or offensive content label detection in a stored video.

          
          

          - **Timestamp** *(integer) --* 

            Time, in milliseconds from the beginning of the video, that the content moderation label was detected. Note that ``Timestamp`` is not guaranteed to be accurate to the individual frame where the moderated content first appears.

            
          

          - **ModerationLabel** *(dict) --* 

            The content moderation label detected by in the stored video.

            
            

            - **Confidence** *(float) --* 

              Specifies the confidence that Amazon Rekognition has that the label has been correctly identified.

               

              If you don't specify the ``MinConfidence`` parameter in the call to ``DetectModerationLabels``, the operation returns labels with a confidence value greater than or equal to 50 percent.

              
            

            - **Name** *(string) --* 

              The label name for the type of unsafe content detected in the image.

              
            

            - **ParentName** *(string) --* 

              The name for the parent label. Labels at the top level of the hierarchy have the parent label ``""``.

              
            

            - **TaxonomyLevel** *(integer) --* 

              The level of the moderation label with regard to its taxonomy, from 1 to 3.

              
        
          

          - **StartTimestampMillis** *(integer) --* 

            The time in milliseconds defining the start of the timeline segment containing a continuously detected moderation label.

            
          

          - **EndTimestampMillis** *(integer) --* 

            The time in milliseconds defining the end of the timeline segment containing a continuously detected moderation label.

            
          

          - **DurationMillis** *(integer) --* 

            The time duration of a segment in milliseconds, I.e. time elapsed from StartTimestampMillis to EndTimestampMillis.

            
          

          - **ContentTypes** *(list) --* 

            A list of predicted results for the type of content an image contains. For example, the image content might be from animation, sports, or a video game.

            
            

            - *(dict) --* 

              Contains information regarding the confidence and name of a detected content type.

              
              

              - **Confidence** *(float) --* 

                The confidence level of the label given

                
              

              - **Name** *(string) --* 

                The name of the label

                
          
        
      
    
      

      - **NextToken** *(string) --* 

        If the response is truncated, Amazon Rekognition Video returns this token that you can use in the subsequent request to retrieve the next set of content moderation labels.

        
      

      - **ModerationModelVersion** *(string) --* 

        Version number of the moderation detection model that was used to detect inappropriate, unwanted, or offensive content.

        
      

      - **JobId** *(string) --* 

        Job identifier for the content moderation operation for which you want to obtain results. The job identifer is returned by an initial call to StartContentModeration.

        
      

      - **Video** *(dict) --* 

        Video file stored in an Amazon S3 bucket. Amazon Rekognition video start operations such as  StartLabelDetection use ``Video`` to specify a video for analysis. The supported file formats are .mp4, .mov and .avi.

        
        

        - **S3Object** *(dict) --* 

          The Amazon S3 bucket name and file name for the video.

          
          

          - **Bucket** *(string) --* 

            Name of the S3 bucket.

            
          

          - **Name** *(string) --* 

            S3 object key name.

            
          

          - **Version** *(string) --* 

            If the bucket is versioning enabled, you can specify the object version.

            
      
    
      

      - **JobTag** *(string) --* 

        A job identifier specified in the call to StartContentModeration and returned in the job completion notification sent to your Amazon Simple Notification Service topic.

        
      

      - **GetRequestMetadata** *(dict) --* 

        Information about the paramters used when getting a response. Includes information on aggregation and sorting methods.

        
        

        - **SortBy** *(string) --* 

          The sorting method chosen for a GetContentModeration request.

          
        

        - **AggregateBy** *(string) --* 

          The aggregation method chosen for a GetContentModeration request.

          
    
  
  **Exceptions**
  
  *   :py:class:`Rekognition.Client.exceptions.AccessDeniedException`

  
  *   :py:class:`Rekognition.Client.exceptions.InternalServerError`

  
  *   :py:class:`Rekognition.Client.exceptions.InvalidParameterException`

  
  *   :py:class:`Rekognition.Client.exceptions.InvalidPaginationTokenException`

  
  *   :py:class:`Rekognition.Client.exceptions.ProvisionedThroughputExceededException`

  
  *   :py:class:`Rekognition.Client.exceptions.ResourceNotFoundException`

  
  *   :py:class:`Rekognition.Client.exceptions.ThrottlingException`

  