afscgap.flat_model

  1"""
  2Model implementation for prejoined Avro flat files.
  3
  4(c) 2025 Regents of University of California / The Eric and Wendy Schmidt Center
  5for Data Science and the Environment at UC Berkeley.
  6
  7This file is part of afscgap released under the BSD 3-Clause License. See
  8LICENSE.md.
  9"""
 10import typing
 11
 12import afscgap.convert
 13import afscgap.model
 14import afscgap.param
 15
 16from afscgap.typesdef import OPT_FLOAT
 17from afscgap.typesdef import OPT_REQUESTOR
 18from afscgap.typesdef import OPT_INT
 19from afscgap.typesdef import OPT_STR
 20
 21PARAMS_DICT = typing.Dict[str, afscgap.param.Param]
 22RECORDS = typing.Iterable[afscgap.model.Record]
 23WARN_FUNCTION = typing.Optional[typing.Callable[[str], None]]
 24
 25RECORD_REQUIRED_FIELDS = [
 26    'area_swept_km2',
 27    'bottom_temperature_c',
 28    'common_name',
 29    'complete',
 30    'count',
 31    'cpue_kgkm2',
 32    'cpue_nokm2',
 33    'curise',
 34    'date_time',
 35    'depth_m',
 36    'distance_fished_km',
 37    'duration_hr',
 38    'haul',
 39    'latitude_dd_end',
 40    'latitude_dd_start',
 41    'longitude_dd_end',
 42    'longitude_dd_start',
 43    'net_height_m',
 44    'net_width_m',
 45    'scientific_name',
 46    'species_code',
 47    'srvy',
 48    'station',
 49    'stratum',
 50    'surface_temperature_c',
 51    'survey',
 52    'survey_definition_id',
 53    'taxon_confidence',
 54    'vessel_id',
 55    'vessel_name',
 56    'weight_kg',
 57    'year'
 58]
 59
 60
 61class ExecuteMetaParams:
 62    """Description of how to execute requests for prejoined Avro flat files.
 63
 64    Collection of configuration parameters of how to execute requests for pre-joined Avro flat files
 65    such as changing the server from which to request those files.
 66    """
 67
 68    def __init__(self, base_url: str, requestor: OPT_REQUESTOR, limit: OPT_INT,
 69        filter_incomplete: bool, presence_only: bool, suppress_large_warning: bool,
 70        warn_func: WARN_FUNCTION):
 71        """Create a new set of configuration values.
 72
 73        Args:
 74            base_url: The URL at which the flat files can be found over HTTPS.
 75            requestor: A requests-like requestor object to use in executing GET requests or None if
 76                to use a default.
 77            limit: The maximum number of records to return or None if all matching records should be
 78                returned.
 79            filter_incomplete: Indicate if incomplete records should be filtered out from the
 80                results set.
 81            presence_only: Indicate if only presence values are required such that zero catch
 82                inference records can be ignored.
 83            suppress_large_warning: Indiciate if the large results set warning should be suppressed,
 84                False if the user should be warned about downloading a very large dataset or True
 85                otherwise.
 86            warn_func: Function to call with a string to emit a warning.
 87        """
 88        self._base_url = base_url
 89        self._requestor = requestor
 90        self._limit = limit
 91        self._filter_incomplete = filter_incomplete
 92        self._presence_only = presence_only
 93        self._suppress_large_warning = suppress_large_warning
 94        self._warn_func = warn_func
 95
 96    def get_base_url(self) -> str:
 97        """Get the URL at which prejoined flat files can be found.
 98
 99        Returns:
100            The URL at which the flat files can be found over HTTPS.
101        """
102        return self._base_url
103
104    def get_requestor(self) -> OPT_REQUESTOR:
105        """Get the requests-like requestor object with which to retrieve records.
106
107        Returns:
108            A requests-like requestor object to use in executing GET requests or None if to use a
109            default.
110        """
111        return self._requestor
112
113    def get_limit(self) -> OPT_INT:
114        """Get the maximum number of matching records to return.
115
116        Returns:
117            The maximum number of records to return or None if all matching records should be
118            returned.
119        """
120        return self._limit
121
122    def get_filter_incomplete(self) -> bool:
123        """Get if "incomplete" records should be filtered out.
124
125        Returns:
126            Flag indicating if incomplete records should be filtered out from the results set.
127        """
128        return self._filter_incomplete
129
130    def get_presence_only(self) -> bool:
131        """Determine if zero catch inference records should be included.
132
133        Returns:
134            Indicate if only presence values are required such that zero catch inference records can
135            be ignored.
136        """
137        return self._presence_only
138
139    def get_suppress_large_warning(self) -> bool:
140        """Determine if the user should see large dataset warnings.
141
142        Returns:
143            Indiciate if the large results set warning should be suppressed, False if the user
144            should be warned about downloading a very large dataset or True otherwise.
145        """
146        return self._suppress_large_warning
147
148    def get_warn_func(self) -> WARN_FUNCTION:
149        """Get the function with which warnings may be emitted.
150
151        Returns:
152            Function to call with a string to emit a warning.
153        """
154        return self._warn_func
155
156
157class HaulKey:
158    """Record describing the key for a flat file haul.
159
160    Record describing the key for a haul within prejoined flat files which can be used in referring
161    to sets of records from a haul (catches) prior to retrieving the collection in its entirety.
162    """
163
164    def __init__(self, year: int, survey: str, haul: int):
165        """Create a new haul key record.
166
167        Args:
168            year: The year of the haul.
169            survey: The name of the survey for which the haul was conducted. This should be the full
170                name like Gulf of Alaska.
171            haul: The haul ID.
172        """
173        self._year = year
174        self._survey = survey
175        self._haul = haul
176
177    def get_year(self) -> int:
178        """Get the year in which the haul was conducted.
179
180        Returns:
181            The year of the haul.
182        """
183        return self._year
184
185    def get_survey(self) -> str:
186        """Get the name of the survey for which this haul was conducted.
187
188        Returns:
189            The name of the survey for which the haul was conducted. This should be the full name
190            like Gulf of Alaska.
191        """
192        return self._survey
193
194    def get_haul(self) -> int:
195        """Get the ID of the haul.
196
197        Returns:
198            The haul ID.
199        """
200        return self._haul
201
202    def get_key(self) -> str:
203        """Get a string uniquely identifying a haul.
204
205        Returns:
206            Unique string describing this haul.
207        """
208        return '%d_%s_%d' % (self._year, self._survey, self._haul)
209
210    def get_path(self) -> str:
211        """Get the path at which the flat file for this haul is expected.
212
213        Returns:
214            Get the URL at which the joined Avro flat file is expected to be found at the flat file
215            server.
216        """
217        return '/joined/%s.avro' % self.get_key()
218
219    def __hash__(self):
220        return hash(self.__repr__())
221
222    def __repr__(self):
223        return self.get_key()
224
225    def __eq__(self, other):
226        if isinstance(other, HaulKey):
227            return self.get_key() == other.get_key()
228        else:
229            return False
230
231    def __ne__(self, other):
232        return (not self.__eq__(other))
233
234
235HAUL_KEYS = typing.Iterable[HaulKey]
236
237
238class FlatRecord(afscgap.model.Record):
239    """Object describing the contents of a pre-joined flat Avro file."""
240
241    def __init__(self, inner):
242        """Create a new object decorating a raw parsed Avro record.
243
244        Args:
245            inner: The Avro record to decorate into a FlatRecord object, conforming to the interface
246                put forward by afscgap.model.Record.
247        """
248        self._inner = inner
249
250    def get_year(self) -> float:
251        """Get the field labeled as year in the API.
252
253        Returns:
254            Year for the survey in which this observation was made or for which
255            an inferred zero catch record was generated.
256        """
257        return self._assert_float(self._inner['year'])
258
259    def get_srvy(self) -> str:
260        """Get the field labeled as srvy in the API.
261
262        Returns:
263            The name of the survey in which this observation or inference was
264            made. NBS (N Bearing Sea), EBS (SE Bearing Sea), BSS (Bearing Sea
265            Slope), or GOA (Gulf of Alaska)
266        """
267        return self._assert_str(self._inner['srvy'])
268
269    def get_survey(self) -> str:
270        """Get the field labeled as survey in the API.
271
272        Returns:
273            Long form description of the survey in which the observation was
274            made or for which an inferred zero catch record was made.
275        """
276        return self._assert_str(self._inner['survey'])
277
278    def get_survey_id(self) -> float:
279        """Get the field labeled as survey_id in the API.
280
281        Returns:
282            Unique numeric ID for the survey.
283        """
284        return self._assert_int(self._inner['survey_definition_id'])
285
286    def get_cruise(self) -> float:
287        """Get the field labeled as cruise in the API.
288
289        Returns:
290            An ID uniquely identifying the cruise in which the observation or
291            inferrence was made. Multiple cruises in a survey.
292        """
293        return self._assert_int(self._inner['cruise'])
294
295    def get_haul(self) -> float:
296        """Get the field labeled as haul in the API.
297
298        Returns:
299            An ID uniquely identifying the haul in which this observation or
300            inference was made. Multiple hauls per cruises.
301        """
302        return self._assert_int(self._inner['haul'])
303
304    def get_stratum(self) -> float:
305        """Get the field labeled as stratum in the API.
306
307        Returns:
308            Unique ID for statistical area / survey combination as described in
309            the metadata or 0 if an experimental tow.
310        """
311        return self._assert_int(self._inner['stratum'])
312
313    def get_station(self) -> str:
314        """Get the field labeled as station in the API.
315
316        Returns:
317            Station associated with the survey.
318        """
319        return self._assert_str(self._inner['station'])
320
321    def get_vessel_name(self) -> str:
322        """Get the field labeled as vessel_name in the API.
323
324        Returns:
325            Unique ID describing the vessel that made this observation or
326            inference.
327        """
328        return self._assert_str(self._inner['vessel_name'])
329
330    def get_vessel_id(self) -> float:
331        """Get the field labeled as vessel_id in the API.
332
333        Returns:
334            Name of the vessel at the time the observation was made with
335            multiple names potentially associated with a vessel ID. May be
336            emulated in the case of inferred records
337        """
338        return self._assert_int(self._inner['vessel_id'])
339
340    def get_date_time(self) -> str:
341        """Get the field labeled as date_time in the API.
342
343        Returns:
344            The date and time of the haul which has been attempted to be
345            transformed to an ISO 8601 string without timezone info. If it
346            couldn’t be transformed, the original string is reported.
347        """
348        return self._assert_str(self._inner['date_time'])
349
350    def get_latitude_start(self, units: str = 'dd') -> float:
351        """Get the field labeled as latitude_dd_start in the API.
352
353        Args:
354            units: The units to return this value in. Only supported is dd for
355                degrees. Deafults to dd.
356
357        Returns:
358            Latitude in decimal degrees associated with the haul.
359        """
360        value = self._assert_float(self._inner['latitude_dd_start'])
361        return self._assert_float(afscgap.convert.convert(value, 'dd', units))
362
363    def get_longitude_start(self, units: str = 'dd') -> float:
364        """Get the field labeled as longitude_dd_start in the API.
365
366        Args:
367            units: The units to return this value in. Only supported is dd for
368                degrees. Deafults to dd.
369
370        Returns:
371            Longitude in decimal degrees associated with the haul.
372        """
373        value = self._assert_float(self._inner['longitude_dd_start'])
374        return self._assert_float(afscgap.convert.convert(value, 'dd', units))
375
376    def get_latitude(self, units: str = 'dd') -> float:
377        """Get midpoint of the haul, approximating deprecated latitude_dd field in the API.
378
379        Args:
380            units: The units to return this value in. Only supported is dd for
381                degrees. Deafults to dd.
382
383        Returns:
384            Latitude in decimal degrees associated with the haul.
385        """
386        start = self.get_latitude_start()
387        end = self.get_latitude_end()
388        mid = (start + end) / 2
389        return self._assert_float(afscgap.convert.convert(mid, 'dd', units))
390
391    def get_longitude(self, units: str = 'dd') -> float:
392        """Get midpoint of the haul, approximating deprecated longitude_dd field in the API.
393
394        Args:
395            units: The units to return this value in. Only supported is dd for
396                degrees. Deafults to dd.
397
398        Returns:
399            Longitude in decimal degrees associated with the haul.
400        """
401        start = self.get_longitude_start()
402        end = self.get_longitude_end()
403        mid = (start + end) / 2
404        return self._assert_float(afscgap.convert.convert(mid, 'dd', units))
405
406    def get_latitude_end(self, units: str = 'dd') -> float:
407        """Get the field labeled as latitude_dd_end in the API.
408
409        Args:
410            units: The units to return this value in. Only supported is dd for
411                degrees. Deafults to dd.
412
413        Returns:
414            Latitude in decimal degrees associated with the haul.
415        """
416        value = self._assert_float(self._inner['latitude_dd_end'])
417        return self._assert_float(afscgap.convert.convert(value, 'dd', units))
418
419    def get_longitude_end(self, units: str = 'dd') -> float:
420        """Get the field labeled as longitude_dd_end in the API.
421
422        Args:
423            units: The units to return this value in. Only supported is dd for
424                degrees. Deafults to dd.
425
426        Returns:
427            Longitude in decimal degrees associated with the haul.
428        """
429        value = self._assert_float(self._inner['longitude_dd_end'])
430        return self._assert_float(afscgap.convert.convert(value, 'dd', units))
431
432    def get_species_code(self) -> OPT_FLOAT:
433        """Get the field labeled as species_code in the API.
434
435        Returns:
436            Unique ID associated with the species observed or for which a zero
437            catch record was inferred.
438        """
439        return self._assert_int_maybe(self._inner['species_code'])
440
441    def get_common_name(self) -> OPT_STR:
442        """Get the field labeled as common_name in the API.
443
444        Returns:
445            The “common name” associated with the species observed or for which
446            a zero catch record was inferred. Example: Pacific glass shrimp.
447        """
448        return self._assert_str_maybe(self._inner['common_name'])
449
450    def get_scientific_name(self) -> OPT_STR:
451        """Get the field labeled as scientific_name in the API.
452
453        Returns:
454            The “scientific name” associated with the species observed or for
455            which a zero catch record was inferred. Example: Pasiphaea pacifica.
456        """
457        value = self._inner['scientific_name']
458        return self._assert_str_maybe(value)
459
460    def get_taxon_confidence(self) -> OPT_STR:
461        """Get the field labeled as taxon_confidence in the API.
462
463        Returns:
464            Confidence flag regarding ability to identify species (High,
465            Moderate, Low). In practice, this can also be Unassessed.
466        """
467        return self._assert_str_maybe(self._inner['taxon_confidence'])
468
469    def get_cpue_weight_maybe(self, units: str = 'kg/ha') -> OPT_FLOAT:
470        """Get a field labeled as cpue_* in the API.
471
472        Args:
473            units: The desired units for the catch per unit effort. Options:
474                kg/ha, kg/km2, kg1000/km2. Defaults to kg/ha.
475
476        Returns:
477            Catch weight divided by net area (in given units) if available. See
478            metadata. None if could not interpret as a float. If an inferred
479            zero catch record, will be zero.
480        """
481        value = self._inner['cpue_kgkm2']
482
483        if value is None:
484            return None
485
486        return afscgap.convert.convert(value, 'kg/km2', units)
487
488    def get_cpue_count_maybe(self, units: str = 'count/ha') -> OPT_FLOAT:
489        """Get the field labeled as cpue_* in the API.
490
491        Get the catch per unit effort from the record with one of the following
492        units: kg/ha, kg/km2, kg1000/km2.
493
494        Args:
495            units: The desired units for the catch per unit effort. Options:
496                count/ha, count/km2, and count1000/km2. Defaults to count/ha.
497
498        Returns:
499            Catch weight divided by net area (in given units) if available. See
500            metadata. None if could not interpret as a float. If an inferred
501            zero catch record, will be zero.
502        """
503        value = self._inner['cpue_nokm2']
504
505        if value is None:
506            return None
507
508        return afscgap.convert.convert(value, 'no/km2', units)
509
510    def get_weight_maybe(self, units: str = 'kg') -> OPT_FLOAT:
511        """Get the field labeled as weight_kg in the API.
512
513        Args:
514            units: The units in which the weight should be returned. Options are
515                g, kg for grams and kilograms respectively. Deafults to kg.
516
517        Returns:
518            Taxon weight if available. See metadata. None if could not
519            interpret as a float. If an inferred zero catch record, will be
520            zero.
521        """
522        value = self._inner['weight_kg']
523
524        if value is None:
525            return None
526
527        return afscgap.convert.convert(value, 'kg', units)
528
529    def get_count_maybe(self) -> OPT_FLOAT:
530        """Get the field labeled as count in the API.
531
532        Returns:
533            Total number of organism individuals in haul. None if could not
534            interpret as a float. If an inferred zero catch record, will be
535            zero.
536        """
537        return self._inner['count']
538
539    def get_bottom_temperature_maybe(self, units: str = 'c') -> OPT_FLOAT:
540        """Get the field labeled as bottom_temperature_c in the API.
541
542        Args:
543            units: The units in which the temperature should be returned.
544                Options: c or f for Celcius and Fahrenheit respectively.
545                Defaults to c.
546
547        Returns:
548            Bottom temperature associated with observation / inferrence if
549            available in desired units. None if not given or could not interpret
550            as a float.
551        """
552        value = self._inner['bottom_temperature_c']
553
554        if value is None:
555            return None
556
557        return afscgap.convert.convert(value, 'c', units)
558
559    def get_surface_temperature_maybe(self, units: str = 'c') -> OPT_FLOAT:
560        """Get the field labeled as surface_temperature_c in the API.
561
562        Args:
563            units: The units in which the temperature should be returned.
564                Options: c or f for Celcius and Fahrenheit respectively.
565                Defaults to c.
566
567        Returns:
568            Surface temperature associated with observation / inferrence if
569            available. None if not given or could not interpret as a float.
570        """
571        value = self._inner['surface_temperature_c']
572
573        if value is None:
574            return None
575
576        return afscgap.convert.convert(value, 'c', units)
577
578    def get_depth(self, units: str = 'm') -> float:
579        """Get the field labeled as depth_m in the API.
580
581        Args:
582            units: The units in which the distance should be returned. Options:
583                m or km for meters and kilometers respectively. Defaults to m.
584
585        Returns:
586            Depth of the bottom.
587        """
588        value = self._assert_float(self._inner['depth_m'])
589        return self._assert_float(afscgap.convert.convert(value, 'm', units))
590
591    def get_distance_fished(self, units: str = 'm') -> float:
592        """Get the field labeled as distance_fished_km in the API.
593
594        Args:
595            units: The units in which the distance should be returned. Options:
596                m or km for meters and kilometers respectively. Defaults to m.
597
598        Returns:
599            Distance of the net fished.
600        """
601        value = self._assert_float(self._inner['distance_fished_km'])
602        return self._assert_float(afscgap.convert.convert(value, 'km', units))
603
604    def get_net_width(self, units: str = 'm') -> float:
605        """Get the field labeled as net_width_m in the API.
606
607        Args:
608            units: The units in which the distance should be returned. Options:
609                m or km for meters and kilometers respectively. Defaults to m.
610
611        Returns:
612            Distance of the net fished after asserting it is given.
613        """
614        value = self._assert_float(self._inner['net_width_m'])
615        return self._assert_float(afscgap.convert.convert(value, 'm', units))
616
617    def get_net_height(self, units: str = 'm') -> float:
618        """Get the field labeled as net_height_m in the API.
619
620        Args:
621            units: The units in which the distance should be returned. Options:
622                m or km for meters and kilometers respectively. Defaults to m.
623
624        Returns:
625            Height of the net fished after asserting it is given.
626        """
627        value = self._assert_float(self._inner['net_height_m'])
628        return self._assert_float(afscgap.convert.convert(value, 'm', units))
629
630    def get_net_width_maybe(self, units: str = 'm') -> OPT_FLOAT:
631        """Get the field labeled as net_width_m in the API.
632
633        Args:
634            units: The units in which the distance should be returned. Options:
635                m or km for meters and kilometers respectively. Defaults to m.
636
637        Returns:
638            Distance of the net fished or None if not given.
639        """
640        value = self._inner['net_width_m']
641
642        if value is None:
643            return None
644
645        return afscgap.convert.convert(value, 'm', units)
646
647    def get_net_height_maybe(self, units: str = 'm') -> OPT_FLOAT:
648        """Get the field labeled as net_height_m in the API.
649
650        Args:
651            units: The units in which the distance should be returned. Options:
652                m or km for meters and kilometers respectively. Defaults to m.
653
654        Returns:
655            Height of the net fished or None if not given.
656        """
657        value = self._inner['net_height_m']
658
659        if value is None:
660            return None
661
662        return afscgap.convert.convert(value, 'm', units)
663
664    def get_area_swept(self, units: str = 'ha') -> float:
665        """Get the field labeled as area_swept_ha in the API.
666
667        Args:
668            units: The units in which the area should be returned. Options:
669                ha, m2, km2. Defaults to ha.
670
671        Returns:
672            Area covered by the net while fishing in desired units.
673        """
674        value = self._assert_float(self._inner['area_swept_km2'])
675        return self._assert_float(afscgap.convert.convert(value, 'km2', units))
676
677    def get_duration(self, units: str = 'hr') -> float:
678        """Get the field labeled as duration_hr in the API.
679
680        Args:
681            units: The units in which the duration should be returned. Options:
682                day, hr, min. Defaults to hr.
683
684        Returns:
685            Duration of the haul.
686        """
687        value = self._assert_float(self._inner['duration_hr'])
688        return self._assert_float(afscgap.convert.convert(value, 'hr', units))
689
690    def get_cpue_weight(self, units: str = 'kg/ha') -> float:
691        """Get the value of field cpue_kgha with validity assert.
692
693        Args:
694            units: The desired units for the catch per unit effort. Options:
695                kg/ha, kg/km2, kg1000/km2. Defaults to kg/ha.
696
697        Raises:
698            AssertionError: Raised if this field was not given by the API or
699            could not be parsed as expected.
700
701        Returns:
702            Catch weight divided by net area (kg / hectares) if available. See
703            metadata. Will be zero if a zero catch record.
704        """
705        value = self._assert_float(self._inner['cpue_kgkm2'])
706        return self._assert_float(afscgap.convert.convert(value, 'kg/km2', units))
707
708    def get_cpue_count(self, units: str = 'count/ha') -> float:
709        """Get the value of field cpue_noha with validity assert.
710
711        Args:
712            units: The desired units for the catch per unit effort. Options:
713                count/ha, count/km2, and count1000/km2. Defaults to count/ha.
714
715        Raises:
716            AssertionError: Raised if this field was not given by the API or
717            could not be parsed as expected.
718
719        Returns:
720            Catch number divided by net sweep area if available (count /
721            hectares). See metadata. Will be zero if a zero catch record.
722        """
723        value = self._assert_float(self._inner['cpue_nokm2'])
724        return self._assert_float(afscgap.convert.convert(value, 'no/km2', units))
725
726    def get_weight(self, units: str = 'kg') -> float:
727        """Get the value of field weight_kg with validity assert.
728
729        Args:
730            units: The units in which the weight should be returned. Options are
731                g, kg for grams and kilograms respectively. Deafults to kg.
732
733        Raises:
734            AssertionError: Raised if this field was not given by the API or
735            could not be parsed as expected.
736
737        Returns:
738            Taxon weight (kg) if available. See metadata. Will be zero if a zero
739            catch record.
740        """
741        value = self._assert_float(self._inner['weight_kg'])
742        return self._assert_float(afscgap.convert.convert(value, 'kg', units))
743
744    def get_count(self) -> float:
745        """Get the value of field count with validity assert.
746
747        Raises:
748            AssertionError: Raised if this field was not given by the API or
749            could not be parsed as expected.
750
751        Returns:
752            Total number of organism individuals in haul. Will be zero if a zero
753            catch record.
754        """
755        return self._assert_int(self._inner['count'])
756
757    def get_bottom_temperature(self, units='c') -> float:
758        """Get the value of field bottom_temperature_c with validity assert.
759
760        Args:
761            units: The units in which the temperature should be returned.
762                Options: c or f for Celcius and Fahrenheit respectively.
763                Defaults to c.
764
765        Raises:
766            AssertionError: Raised if this field was not given by the API or
767            could not be parsed as expected.
768
769        Returns:
770            Bottom temperature associated with observation / inferrence if
771            available.
772        """
773        value = self._assert_float(self._inner['bottom_temperature_c'])
774        return self._assert_float(afscgap.convert.convert(value, 'c', units))
775
776    def get_surface_temperature(self, units='c') -> float:
777        """Get the value of field surface_temperature_c with validity assert.
778
779        Args:
780            units: The units in which the temperature should be returned.
781                Options: c or f for Celcius and Fahrenheit respectively.
782                Defaults to c.
783
784        Raises:
785            AssertionError: Raised if this field was not given by the API or
786            could not be parsed as expected.
787
788        Returns:
789            Surface temperature associated with observation / inferrence if
790            available.
791        """
792        value = self._assert_float(self._inner['surface_temperature_c'])
793        return self._assert_float(afscgap.convert.convert(value, 'c', units))
794
795    def is_complete(self) -> bool:
796        """Determine if this record has all of its values filled in.
797
798        Returns:
799            True if all optional fields have a parsed value with the expected
800            type and false otherwise.
801        """
802        if not self._inner['complete']:
803            return False
804
805        fields_missing = filter(lambda x: self._inner.get(x, None) is None, RECORD_REQUIRED_FIELDS)
806        num_missing = sum(map(lambda x: 1, fields_missing))
807        return num_missing == 0
808
809    def get_inner(self):
810        """Get the raw parsed Avro payload.
811
812        Returns:
813            The raw parsed Avro payload.
814        """
815        return self._inner
816
817    def _assert_float(self, target) -> float:
818        assert target is not None
819        return float(target)
820
821    def _assert_float_maybe(self, target) -> OPT_FLOAT:
822        return None if target is None else float(target)
823
824    def _assert_str(self, target) -> str:
825        assert target is not None
826        return str(target)
827
828    def _assert_str_maybe(self, target) -> OPT_STR:
829        return None if target is None else str(target)
830
831    def _assert_int(self, target) -> int:
832        assert target is not None
833        return int(target)
834
835    def _assert_int_maybe(self, target) -> OPT_INT:
836        return None if target is None else int(target)