cdasws 1.8.2__tar.gz → 1.8.3__tar.gz

{cdasws-1.8.2 → cdasws-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cdasws
-Version: 1.8.2
+Version: 1.8.3
 Summary: NASA's Coordinated Data Analysis System Web Service Client Library
 Home-page: https://cdaweb.gsfc.nasa.gov/WebServices/REST
 Author: Bernie Harris

{cdasws-1.8.2 → cdasws-1.8.3}/cdasws/__init__.py

@@ -60,12 +60,14 @@ import os
 import platform
 import logging
 import re
+from importlib.util import find_spec
 import urllib.parse
 from urllib.parse import urlparse
 import json
 from operator import itemgetter
 import time
 from datetime import datetime, timedelta, timezone
+import xml.etree.ElementTree as ET
 from tempfile import mkstemp
 from typing import Any, Callable, Dict, List, Tuple, Union
 
@@ -79,11 +81,19 @@ from cdasws.datarequest import ImageFormat, GraphOptions, GraphRequest
 from cdasws.datarequest import TextFormat, TextRequest, ThumbnailRequest
 from cdasws.timeinterval import TimeInterval
 
-try:
+
+# requires python >= 3.4
+if find_spec('spacepy.datamodel') is not None:
     import spacepy.datamodel as spdm    # type: ignore
     SPDM_AVAILABLE = True
-except ImportError:
+else:
     SPDM_AVAILABLE = False
+# python < 3.4
+#try:
+#    import spacepy.datamodel as spdm    # type: ignore
+#    SPDM_AVAILABLE = True
+#except ImportError:
+#    SPDM_AVAILABLE = False
 
 try:
     from cdflib.xarray import cdf_to_xarray
@@ -127,7 +137,7 @@ except ImportError:
         CDF_XARRAY_AVAILABLE = False
 
 
-__version__ = "1.8.2"
+__version__ = "1.8.3"
 
 
 #
@@ -136,6 +146,22 @@ __version__ = "1.8.2"
 #
 RETRY_LIMIT = 100
 
+#
+# XML schema namespace
+#
+NS = 'http://cdaweb.gsfc.nasa.gov/schema'
+#
+# XHTML schema namespace
+#
+XHTML_NS = 'http://www.w3.org/1999/xhtml'
+#
+# All namespaces found in responses.
+#
+NAMESPACES = {
+    'cdas': NS,
+    'xhtml': XHTML_NS
+}
+
 
 def _get_data_progress(
         progress: float,
@@ -257,7 +283,7 @@ class CdasWs:
 
         self._request_headers = {
             'Content-Type' : 'application/json',
-            'Accept' : 'application/json',
+            'Accept' : 'application/xml',
             'User-Agent' : self._user_agent,
             #'Accept-Encoding' : 'gzip'  # only beneficial for icdfml responses
         }
@@ -339,17 +365,28 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        observatory_groups = response.json()
-
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('observatory_groups: %s',
-                              json.dumps(observatory_groups,
-                                         indent=4, sort_keys=True))
+            self.logger.debug('response.text = %s', response.text)
 
-        if not observatory_groups:
-            return []
+        observatory_response = ET.fromstring(response.text)
+
+        observatory_group_descriptions = []
+        for description in observatory_response.findall(\
+            'cdas:ObservatoryGroupDescription', namespaces=NAMESPACES):
+
+            observatory_ids = []
+            for observatory_id in description.findall(\
+                'cdas:ObservatoryId', namespaces=NAMESPACES):
+
+                observatory_ids.append(observatory_id.text)
 
-        return observatory_groups['ObservatoryGroupDescription']
+            observatory_group_descriptions.append({
+                'Name': description.find(\
+                    'cdas:Name', namespaces=NAMESPACES).text,
+                'ObservatoryId': observatory_ids
+            })
+
+        return observatory_group_descriptions
 
 
     def get_instrument_types(
@@ -399,17 +436,24 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        instrument_types = response.json()
+        if self.logger.level <= logging.DEBUG:
+            self.logger.debug('response.text = %s', response.text)
+
+        instrument_response = ET.fromstring(response.text)
 
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('instrument_types = %s',
-                              json.dumps(instrument_types, indent=4,
-                                         sort_keys=True))
+            self.logger.debug('instrument_response = %s',
+                              ET.tostring(instrument_response))
 
-        if not instrument_types:
-            return []
+        instrument_types = []
+        for description in instrument_response.findall(\
+            'cdas:InstrumentTypeDescription', namespaces=NAMESPACES):
 
-        return instrument_types['InstrumentTypeDescription']
+            instrument_types.append({
+                'Name': description.find('cdas:Name',
+                                         namespaces=NAMESPACES).text
+                })
+        return instrument_types
 
 
     def get_instruments(
@@ -459,17 +503,29 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        instruments = response.json()
+        if self.logger.level <= logging.DEBUG:
+            self.logger.debug('response.text = %s', response.text)
+
+        instruments_response = ET.fromstring(response.text)
 
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('instruments = %s',
-                              json.dumps(instruments, indent=4,
-                                         sort_keys=True))
+            self.logger.debug('instruments = %s', response.text)
+                              #ET.indent(instruments_response, space='    '))
 
-        if not instruments:
-            return []
+        instruments = []
+        for instrument_description in instruments_response.findall(\
+            'cdas:InstrumentDescription', namespaces=NAMESPACES):
 
-        return instruments['InstrumentDescription']
+            instruments.append({
+                'Name': instrument_description.find(\
+                    'cdas:Name', namespaces=NAMESPACES).text,
+                'ShortDescription': instrument_description.find(\
+                    'cdas:ShortDescription', namespaces=NAMESPACES).text,
+                'LongDescription': instrument_description.find(\
+                    'cdas:LongDescription', namespaces=NAMESPACES).text
+            })
+
+        return instruments
 
 
     def get_observatories(
@@ -519,17 +575,28 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        observatories = response.json()
+        if self.logger.level <= logging.DEBUG:
+            self.logger.debug('response.text = %s', response.text)
+
+        observatory_response = ET.fromstring(response.text)
 
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('observatories = %s',
-                              json.dumps(observatories, indent=4,
-                                         sort_keys=True))
+            self.logger.debug('observatories = %s', response.text)
 
-        if not observatories:
-            return []
+        observatories = []
+
+        for observatory in observatory_response.findall(\
+            'cdas:ObservatoryDescription', namespaces=NAMESPACES):
+            observatories.append({
+                'Name': observatory.find(\
+                    'cdas:Name', namespaces=NAMESPACES).text,
+                'ShortDescription': observatory.find(\
+                    'cdas:ShortDescription', namespaces=NAMESPACES).text,
+                'LongDescription': observatory.find(\
+                    'cdas:LongDescription', namespaces=NAMESPACES).text
+            })
 
-        return observatories['ObservatoryDescription']
+        return observatories
 
 
     def get_observatory_groups_and_instruments(
@@ -574,17 +641,55 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        observatories = response.json()
-
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('observatories = %s',
-                              json.dumps(observatories, indent=4,
-                                         sort_keys=True))
+            self.logger.debug('response.text = %s', response.text)
 
-        if not observatories:
-            return []
+        observatories_response = ET.fromstring(response.text)
 
-        return observatories['ObservatoryGroupInstrumentDescription']
+        if self.logger.level <= logging.DEBUG:
+            self.logger.debug('observatories = %s', response.text)
+
+        o_g_i_ds = []
+
+        for o_g_i_d in observatories_response.findall(\
+            'cdas:ObservatoryGroupInstrumentDescription',\
+            namespaces=NAMESPACES):
+
+            o_g_i_d_name = o_g_i_d.find('cdas:Name',
+                                        namespaces=NAMESPACES).text
+            o_is = []
+            for o_i in o_g_i_d.findall('cdas:ObservatoryInstruments',
+                                       namespaces=NAMESPACES):
+
+                o_i_name = o_i.find('cdas:Name',
+                                    namespaces=NAMESPACES).text
+                i_ds = []
+                for i_d in o_i.findall('cdas:InstrumentDescription',
+                                       namespaces=NAMESPACES):
+                    i_d_name = i_d.find('cdas:Name',
+                                        namespaces=NAMESPACES).text
+                    i_d_short_description = \
+                        i_d.find('cdas:ShortDescription',
+                                 namespaces=NAMESPACES).text
+                    i_d_long_description = \
+                         i_d.find('cdas:LongDescription',
+                                  namespaces=NAMESPACES).text
+                    i_ds.append({
+                        'Name': i_d_name,
+                        'ShortDescription': i_d_short_description,
+                        'LongDescription': i_d_long_description
+                    })
+                o_is.append({
+                    'Name': o_i_name,
+                    'InstrumentDescription': i_ds
+                })
+
+            o_g_i_ds.append({
+                'Name': o_g_i_d_name,
+                'ObservatoryInstruments': o_is
+            })
+
+        return o_g_i_ds
 
 
     # pylint: disable=too-many-branches
@@ -711,16 +816,97 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        datasets = response.json()
-
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('datasets = %s',
-                              json.dumps(datasets, indent=4, sort_keys=True))
+            self.logger.debug('response.text = %s', response.text)
 
-        if not datasets:
-            return []
+        dss = ET.fromstring(response.text)
 
-        return sorted(datasets['DatasetDescription'], key=itemgetter('Id'))
+        if self.logger.level <= logging.DEBUG:
+            self.logger.debug('datasets = %s', response.text)
+
+        datasets = []
+        for ds in dss.findall('cdas:DatasetDescription',
+                              namespaces=NAMESPACES):
+
+            observatory_groups = []
+            for o_g in ds.findall('cdas:ObservatoryGroup',
+                                  namespaces=NAMESPACES):
+                observatory_groups.append(o_g.text)
+
+            instrument_types = []
+            for i_t in ds.findall('cdas:InstrumentType',
+                                  namespaces=NAMESPACES):
+                instrument_types.append(i_t.text)
+
+            dataset_links = []
+            for d_l in ds.findall('cdas:DatasetLink',
+                                  namespaces=NAMESPACES):
+                dataset_links.append({
+                    'Title': d_l.find('cdas:Title',
+                                      namespaces=NAMESPACES).text,
+                    'Text': d_l.find('cdas:Text',
+                                     namespaces=NAMESPACES).text,
+                    'Url': d_l.find('cdas:Url',
+                                    namespaces=NAMESPACES).text,
+                })
+
+            observatories = []
+            for obs_elem in ds.findall('cdas:Observatory',
+                                       namespaces=NAMESPACES):
+                observatories.append(obs_elem.text)
+
+            instruments = []
+            for instr_elem in ds.findall('cdas:Instrument',
+                                         namespaces=NAMESPACES):
+                instruments.append(instr_elem.text)
+
+            dataset = {
+                'Id': ds.find('cdas:Id', namespaces=NAMESPACES).text,
+                'Observatory': observatories,
+                'Instrument': instruments,
+                'ObservatoryGroup': observatory_groups,
+                'InstrumentType': instrument_types,
+                'Label': ds.find('cdas:Label',
+                                 namespaces=NAMESPACES).text,
+                'TimeInterval': {
+                    'Start': ds.find('cdas:TimeInterval/cdas:Start',
+                                     namespaces=NAMESPACES).text,
+                    'End': ds.find('cdas:TimeInterval/cdas:End',
+                                   namespaces=NAMESPACES).text
+                },
+                'PiName': ds.find('cdas:PiName',
+                                  namespaces=NAMESPACES).text,
+                'PiAffiliation': ds.find('cdas:PiAffiliation',
+                                         namespaces=NAMESPACES).text,
+                'Notes': ds.find('cdas:Notes',
+                                 namespaces=NAMESPACES).text,
+                'DatasetLink': dataset_links
+            }
+            doi = ds.find('cdas:Doi', namespaces=NAMESPACES)
+            if doi is not None:
+                dataset['Doi'] = doi.text
+
+            spase_resource_id = ds.find('cdas:SpaseResourceId',
+                                        namespaces=NAMESPACES)
+            if spase_resource_id is not None:
+                dataset['SpaseResourceId'] = spase_resource_id.text
+
+            additional_metadata = []
+            for add_meta in ds.findall('cdas:AdditionalMetadata',
+                                       namespaces=NAMESPACES):
+                meta_type = add_meta.attrib['Type']
+                value = add_meta.text
+                additional_metadata.append({
+                    'Type': meta_type,
+                    'value': value
+                })
+
+            if len(additional_metadata) > 0:
+                dataset['AdditionalMetadata'] = additional_metadata
+
+            datasets.append(dataset)
+
+        return sorted(datasets, key=itemgetter('Id'))
     # pylint: enable=too-many-branches
 
 
@@ -791,24 +977,23 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        inventory = response.json()
-
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('inventory = %s',
-                              json.dumps(inventory, indent=4, sort_keys=True))
+            self.logger.debug('response.text = %s', response.text)
 
+        inventory = ET.fromstring(response.text)
         intervals = []
-
-        data_intervals = inventory['InventoryDescription'][0]
-
-        if 'TimeInterval' in data_intervals:
-
-            for time_interval in data_intervals['TimeInterval']:
-
+        for inventory_desc in inventory.findall(\
+                                  'cdas:InventoryDescription',
+                                  namespaces=NAMESPACES):
+            for time_interval in inventory_desc.findall(\
+                                     'cdas:TimeInterval',
+                                     namespaces=NAMESPACES):
                 intervals.append(
                     TimeInterval(
-                        time_interval['Start'],
-                        time_interval['End']
+                        time_interval.find('cdas:Start',
+                                           namespaces=NAMESPACES).text,
+                        time_interval.find('cdas:End',
+                                           namespaces=NAMESPACES).text
                     )
                 )
 
@@ -881,12 +1066,36 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return []
 
-        variables = response.json()
+        if self.logger.level <= logging.DEBUG:
+            self.logger.debug('response.text = %s', response.text)
 
-        if not variables:
-            return []
+        var_descriptions = ET.fromstring(response.text)
+
+        variables = []
+        for var_description in var_descriptions.findall(\
+                                   'cdas:VariableDescription',
+                                   namespaces=NAMESPACES):
+            name = var_description.find('cdas:Name',
+                                        namespaces=NAMESPACES).text
+            short_description = var_description.find(\
+                                        'cdas:ShortDescription',
+                                        namespaces=NAMESPACES).text
+            if short_description is None:
+                short_description = ''
+
+            long_description = var_description.find(\
+                                        'cdas:LongDescription',
+                                        namespaces=NAMESPACES).text
+            if long_description is None:
+                long_description = ''
 
-        return variables['VariableDescription']
+            variables.append({
+                'Name': name,
+                'ShortDescription': short_description,
+                'LongDescription': long_description
+            })
+
+        return variables
 
 
     def get_variable_names(
@@ -915,6 +1124,143 @@ class CdasWs:
         return variable_names
 
 
+    @staticmethod
+    def _get_thumbnail_description_dict(
+            file_description_elem: ET.Element
+        ) -> Dict:
+        """
+        Gets ThumbnailDescription dictionary representation from the
+        given FileDescription element.
+
+        Parameters
+        ----------
+        file_description_elem
+            a FileDescription Element.
+        Returns
+        -------
+        Dict
+            a Dictionary representation of the ThumbnailDescription
+            contained in the given FileDescription element.
+        """
+        thumbnail_desc = file_description_elem.find(\
+                             'cdas:ThumbnailDescription',
+                             namespaces=NAMESPACES)
+        if thumbnail_desc is not None:
+            time_interval = thumbnail_desc.find('cdas:TimeInterval',
+                                                namespaces=NAMESPACES)
+            start = time_interval.find('cdas:Start',
+                                       namespaces=NAMESPACES).text
+            end = time_interval.find('cdas:End',
+                                     namespaces=NAMESPACES).text
+            return {
+                'Name': thumbnail_desc.find('cdas:Name',
+                                            namespaces=NAMESPACES).text,
+                'Dataset': thumbnail_desc.find('cdas:Dataset',
+                                               namespaces=NAMESPACES).text,
+                'TimeInterval': {
+                    'Start': start,
+                    'End': end
+                },
+                'VarName': thumbnail_desc.find('cdas:VarName',
+                                               namespaces=NAMESPACES).text,
+                'Options': int(thumbnail_desc.find(\
+                                   'cdas:Options',
+                                   namespaces=NAMESPACES).text),
+                'NumFrames': int(thumbnail_desc.find(\
+                                     'cdas:NumFrames',
+                                     namespaces=NAMESPACES).text),
+                'NumRows': int(thumbnail_desc.find(\
+                                   'cdas:NumRows',
+                                   namespaces=NAMESPACES).text),
+                'NumCols': int(thumbnail_desc.find(\
+                                   'cdas:NumCols',
+                                   namespaces=NAMESPACES).text),
+                'TitleHeight': int(thumbnail_desc.find(\
+                                       'cdas:TitleHeight',
+                                       namespaces=NAMESPACES).text),
+                'ThumbnailHeight': int(thumbnail_desc.find(\
+                                           'cdas:ThumbnailHeight',
+                                           namespaces=NAMESPACES).text),
+                'ThumbnailWidth': int(thumbnail_desc.find(\
+                                           'cdas:ThumbnailWidth',
+                                           namespaces=NAMESPACES).text),
+                'StartRecord': int(thumbnail_desc.find(\
+                                       'cdas:StartRecord',
+                                       namespaces=NAMESPACES).text),
+                'MyScale': float(thumbnail_desc.find(\
+                                     'cdas:MyScale',
+                                     namespaces=NAMESPACES).text),
+                'XyStep': float(thumbnail_desc.find(\
+                                    'cdas:XyStep',
+                                    namespaces=NAMESPACES).text)
+            }
+        return None
+
+
+    @staticmethod
+    def _get_data_result_dict(
+            xml_data_result: str
+        ) -> Dict:
+        """
+        Gets DataResult dictionary representation from the
+        given XML DataResult element.
+
+        Parameters
+        ----------
+        xml_data_result
+            XML representation of a DataResult.
+        Returns
+        -------
+        Dict
+            a Dictionary representation of the given XML representation
+            of a DataResult.
+        """
+        data_result = ET.fromstring(xml_data_result)
+        file_descriptions = []
+        for file_description in data_result.findall(\
+            'cdas:FileDescription', namespaces=NAMESPACES):
+
+            dict_file_description = {
+                'Name': file_description.find('cdas:Name',
+                                              namespaces=NAMESPACES).text,
+                'MimeType': file_description.find(\
+                                'cdas:MimeType',
+                                namespaces=NAMESPACES).text,
+                'StartTime': file_description.find(\
+                                 'cdas:StartTime',
+                                 namespaces=NAMESPACES).text,
+                'EndTime': file_description.find(\
+                               'cdas:EndTime',
+                               namespaces=NAMESPACES).text,
+                'Length': int(file_description.find(\
+                                  'cdas:Length',
+                                  namespaces=NAMESPACES).text),
+                'LastModified': file_description.find(\
+                                    'cdas:LastModified',
+                                    namespaces=NAMESPACES).text
+            }
+            thumbnail_dict = CdasWs._get_thumbnail_description_dict(\
+                                     file_description)
+            if thumbnail_dict is not None:
+                dict_file_description['ThumbnailDescription'] = \
+                    thumbnail_dict
+
+            thumbnail_id_elem = file_description.find(\
+                                    'cdas:ThumbnailId',
+                                    namespaces=NAMESPACES)
+            if thumbnail_id_elem is not None:
+                dict_file_description['ThumbnailId'] = \
+                    thumbnail_id_elem.text
+
+            file_descriptions.append(dict_file_description)
+
+        if len(file_descriptions) > 0:
+            return {
+                'FileDescription': file_descriptions
+            }
+        return None
+
+
     def get_data_result(
             self,
             data_request: DataRequest,
@@ -962,18 +1308,10 @@ class CdasWs:
             response = self._session.post(url, data=data_request.json(),
                                           timeout=self._timeout)
 
-            try:
-                data_result = response.json()
-            except ValueError:
-                # for example, a 503 from apache will not be json
-                self.logger.debug('Non-JSON response: %s', response.text)
-
-            if self.logger.level <= logging.DEBUG:
-                self.logger.debug('data_result = %s',
-                                  json.dumps(data_result, indent=4,
-                                             sort_keys=True))
             if response.status_code == 200:
 
+                data_result = CdasWs._get_data_result_dict(response.text)
+
                 if not data_result:
                     return (response.status_code, None)
 
@@ -1074,7 +1412,7 @@ class CdasWs:
         --------
         CdasWs.get_data : In addition to what get_data_file does,
             get_data also downloads and reads the data file into memory
-            (SpaceData object).
+            (SpaceData or xarray.Dataset object).
         """
         # pylint: disable=too-many-locals
         # pylint: disable=too-many-return-statements
@@ -1308,7 +1646,7 @@ class CdasWs:
         Tuple
             [0] contains a dictionary of HTTP and CDAS status information.
             When successful, ['http']['status_code'] will be 200.<br>
-            [1] contains the requested data (SpaceData or xarray.Dateset
+            [1] contains the requested data (SpaceData or xarray.Dataset
             object) or None.
         Raises
         ------
@@ -1972,14 +2310,20 @@ class CdasWs:
             self.logger.info('response.text: %s', response.text)
             return (response.status_code, None)
 
-        results = response.json()
-
         if self.logger.level <= logging.DEBUG:
-            self.logger.debug('results: %s',
-                              json.dumps(results,
-                                         indent=4, sort_keys=True))
+            self.logger.debug('response.text = %s', response.text)
 
-        if not results:
-            return (response.status_code, None)
+        results = ET.fromstring(response.text)
+
+        ssc_id = []
+        for ssc_id_elem in results.findall('SscId'):
+            ssc_id.append(ssc_id_elem.text)
+
+        if len(ssc_id) == 0:
+            result = None
+        elif len(ssc_id) == 1:
+            result = ssc_id[0]
+        else:
+            result = ssc_id
 
-        return (response.status_code, results.get('SscId', None))
+        return (response.status_code, result)

{cdasws-1.8.2 → cdasws-1.8.3}/cdasws/datarequest.py

@@ -24,7 +24,7 @@
 #
 # NOSA HEADER END
 #
-# Copyright (c) 2019-2023 United States Government as represented by
+# Copyright (c) 2019-2024 United States Government as represented by
 # the National Aeronautics and Space Administration. No copyright is
 # claimed in the United States under Title 17, U.S.Code. All Other
 # Rights Reserved.
@@ -36,7 +36,7 @@ Package defining classes to represent the DataRequestEntity and its
 sub-classes from
 <https://cdaweb.gsfc.nasa.gov/WebServices/REST/CDAS.xsd>.<br>
 
-Copyright &copy; 2019-2023 United States Government as represented by the
+Copyright &copy; 2019-2024 United States Government as represented by the
 National Aeronautics and Space Administration. No copyright is claimed in
 the United States under Title 17, U.S.Code. All Other Rights Reserved.
 """
@@ -378,6 +378,7 @@ class GraphOptions:
         related variables from different datasets will result in the
         same graphs being produced as when the option is not included.
     """
+    # pylint: disable=too-many-arguments
     def __init__(self,
                  coarse_noise_filter: bool = False,
                  x_axis_width_factor: int = 3,
@@ -391,6 +392,7 @@ class GraphOptions:
         self._y_axis_height_factor = y_axis_height_factor
         self._combine = combine
         self._overplot = overplot
+    # pylint: enable=too-many-arguments
 
 
     @property

{cdasws-1.8.2 → cdasws-1.8.3}/cdasws.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cdasws
-Version: 1.8.2
+Version: 1.8.3
 Summary: NASA's Coordinated Data Analysis System Web Service Client Library
 Home-page: https://cdaweb.gsfc.nasa.gov/WebServices/REST
 Author: Bernie Harris

{cdasws-1.8.2 → cdasws-1.8.3}/setup.py

@@ -10,7 +10,7 @@ README = (HERE / "README.md").read_text()
 # This call to setup() does all the work
 setup(
     name="cdasws",
-    version="1.8.2",
+    version="1.8.3",
     description="NASA's Coordinated Data Analysis System Web Service Client Library",
     long_description=README,
     long_description_content_type="text/markdown",
@@ -19,6 +19,7 @@ setup(
     author_email="NASA-SPDF-Support@nasa.onmicrosoft.com",
     license="NOSA",
     packages=["cdasws"],
+#    python_requires=[">3.4"]
 #    packages=find_packages(exclude=["tests"]),
 #    packages=find_packages(),
     include_package_data=True,