def parse_args()

in analysis/webservice/algorithms/Tomogram.py [0:0]

• 75 lines of code
• 24 McCabe index (conditional complexity)

    def parse_args(self, compute_options):
        ds, parameter = super().parse_args(compute_options)

        def get_required_int(name):
            val = compute_options.get_int_arg(name, None)

            if val is None:
                raise NexusProcessingException(reason=f'Missing required parameter: {name}', code=400)

            return val

        def get_required_point(name):
            val = compute_options.get_argument(name, None)

            if val is None:
                raise NexusProcessingException(reason=f'Missing required parameter: {name}', code=400)

            val = val.split(',')

            if len(val) != 2:
                raise NexusProcessingException(reason=f'Invalid parameter: {name}={val}. Incorrect number of fields, '
                                                      f'need 2', code=400)

            try:
                longitude = float(val[0])
            except ValueError:
                raise NexusProcessingException(reason='Longitude must be numeric', code=400)

            try:
                latitude = float(val[1])
            except ValueError:
                raise NexusProcessingException(reason='Latitude must be numeric', code=400)

            if longitude < -180 or longitude > 180 or isnan(longitude):
                raise NexusProcessingException(
                    reason='Longitude must be non-nan and between -180 and 180', code=400
                )

            if latitude < -90 or latitude > 90 or isnan(latitude):
                raise NexusProcessingException(
                    reason='Latitude must be non-nan and between -90 and 90', code=400
                )

            return Point(longitude, latitude)

        start_point = get_required_point('p1')
        end_point = get_required_point('p2')

        min_elevation = get_required_int('minElevation')
        max_elevation = get_required_int('maxElevation')

        if min_elevation >= max_elevation:
            raise NexusProcessingException(
                reason='Min elevation must be less than max elevation', code=400
            )

        horizontal_margin = compute_options.get_float_arg('horizontalMargin', 0.001)

        ch_ds = compute_options.get_argument('canopy_ds', None)
        g_ds = compute_options.get_argument('ground_ds', None)

        if ch_ds is not None:
            ch_ds = [v.strip() for v in ch_ds.split(',')]
        else:
            ch_ds = []

        if len(ch_ds) > 2:
            raise NexusProcessingException(
                reason='Too many datasets provided for canopy_ds', code=400
            )

        if g_ds is not None:
            g_ds = [v.strip() for v in g_ds.split(',')]
        else:
            g_ds = []

        if len(g_ds) > 2:
            raise NexusProcessingException(
                reason='Too many datasets provided for ground_ds', code=400
            )

        output = compute_options.get_content_type().lower()

        if output in ['csv', 'zip']:
            raise NexusProcessingException(reason=f'Output {output} unsupported', code=400)

        percentiles = compute_options.get_boolean_arg('elevPercentiles')

        if percentiles and (ch_ds is None or g_ds is None):
            raise NexusProcessingException(
                code=400,
                reason='\'elevPercentiles\' argument requires \'canopy_ds\' and \'ground_ds\' be set'
            )

        peaks = compute_options.get_boolean_arg('peaks') and not percentiles

        cmap = mpl.colormaps.get(
            compute_options.get_argument('cmap', 'viridis'),
            mpl.colormaps['viridis']
        )

        return (ds, parameter, start_point, end_point, min_elevation, max_elevation,horizontal_margin, peaks, ch_ds,
                g_ds, percentiles, cmap)