asf_cherry_pick 2.0.2__py3-none-any.whl

asf_cherry_pick/__init__.py

@@ -0,0 +1,4 @@
+
+import importlib.metadata
+
+__version__ = importlib.metadata.version("asf_cherry_pick")

asf_cherry_pick/asf_cherry_pick.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+
+"""
+
+Script that can fetch part of zip file of sentinel1 data from ASF.
+
+Requirement: have an access (ie login, passwd) at asf.
+
+Algorithm:
+=========
+
+The algorithm is two folds:
+
+    i) get the set of urls that matchs a given query. The goegraphical query is
+    done through a kml file. A orbit has to be provided that allows to select
+    either a ascending or descending track. A time range is also mandatory.
+    ii) Downlowd from the url the data in the zip files that match the pattern.
+    This can be used either to download only one tiff file (e.g. one polarisation, one subswath)
+    or meta data like e.g. xml files.
+
+Dependencies
+============
+The script depends upon the asf_search tool that can be installed using pypi.
+The script also uses remotezip package, which has to be modified. We thus embed the modified version.
+
+
+Examples:
+=========
+
+url.txt contains urls (one per line) that can be fetched from asf (like e.g. )
+products contains safe names, one per line.
+D041_S1_Mexique.kml is a kml containing a polygon that represent the region of interest
+
+
+
+asf_cherry_pick --kml D041_S1_Mexique.kml -d 2019-01-30:2020-01-23  -c credentials.txt -v 4 -o D041 --saveproducts to_download.txt
+asf_cherry_pick --urls url -c credentials.txt -o A0034
+asf_cherry_pick --safelist products -c credentials.txt -o A0034
+
+
+API example:
+===========
+
+import asf_search as asf
+from fastkml import kml, geometry
+import nsb_remotezip as remotezip
+import flatsim_get_xml_from_kml as fx
+
+picker = fx.AsfCherryPick()
+roi = [(-98.82686004479159, 20.4077763126375),
+       (-101.1931787671002, 20.81921608915112),
+       (-101.8919952521377, 17.07545047337062),
+       (-99.55373281701526, 16.60957331722261),
+       (-98.82686004479159, 20.4077763126375)]
+picker.search_urls(roi, 'D041', '2019-01-30', '2020-01-23')
+print(f"urls= {picker.urls}")
+picker.connect(user, passwd)
+nb_processes = 4
+picker.cherry_pick_all(target_dir, '(manifest.safe|s1.*xml$)', nb_processes)
+
+"""
+
+# classical imports
+#        from IPython import embed; embed()
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+import multiprocessing
+from multiprocessing import Pool
+import re
+
+import asf_search as asf
+from fastkml import kml, geometry
+import remotezip
+
+logger = logging.getLogger(__name__)
+
+
+class AsfCherryPick(object):
+
+    """AsfCherryPick. A class for picking data at asf."""
+
+    def __init__(self, temp_dir="./asf_tmp"):
+        """Initialize the cherry picker
+            :roi: (str) region of interest (format )
+            :orbit: (str) orbit in the form D041
+            :auth_file: (str) a file containing login passwd information
+            :processes: (int) nb of download in //. all the cpus if None,
+                        default=1
+        """
+        self.auth = None
+        self.tempdir = Path(temp_dir)
+        self.tempdir.mkdir(parents=True, exist_ok=True)
+        # self.cookiejar = None
+        # self.cookiejar_session = None
+
+    def search_urls(self, roi, orbit, start_date='2014-09-01', end_date='2022-06-01'):
+        """ search the urls that fit the requirements and updates self.urls member
+        :roi: list of (lon, lat) tuple
+        :orbit: (str) string of format like A001 of D089
+        :start_date: (str) start date, format YYYY-MM-DD
+        :end_date: (str) start date, format YYYY-MM-DD
+        """
+        roi_string = [(str(x[0]), str(x[1])) for x in roi]
+        relative_orbit = orbit.lstrip('AD')
+        direction = 'ASCENDING' if orbit[0] == 'A' else "DESCENDING"
+        aoi = 'polygon((' + \
+            ','.join([' '.join(x) for x in roi_string]) + \
+            '))'
+        opts = {
+            'platform': asf.PLATFORM.SENTINEL1,
+            'relativeOrbit': relative_orbit,
+            'processingLevel': 'SLC',
+            'beamMode': 'IW',
+            'flightDirection': direction,
+            'start': start_date+'T00:00:00Z',
+            'end': end_date+'T23:59:59Z'
+        }
+        logger.debug(f'looking for {opts}')
+        results = asf.geo_search(intersectsWith=aoi, **opts)
+        logger.info(f"found {len(results)} results")
+        self.urls = []
+        for product in results:
+            product_dict = product.geojson()
+            self.urls.append(product_dict['properties']['url'])
+        logger.info(f"found {self.urls}, {len(self.urls)} products")
+
+    def connect(self, user, passwd):
+        """Authenticate and update the session.
+
+        :user: (str) the asf user
+        :passwd: (str) the asf passwrd
+        """
+        self.auth = asf.ASFSession()
+        self.auth.auth_with_creds(user, passwd)
+        # self.cookiejar = self.auth.cookies
+        # self.cookiejar_session = asf.ASFSession().auth_with_cookiejar(self.cookiejar)
+
+    def cherry_pick_all(self, target_dir, pattern='(manifest.safe|annotation.*/s1.*.xml)', processes=None):
+        """Fetch from the url the elemtents that matches pattern and send then in target dir.
+           connect method should have been called and urls not empty.
+           RuntimeError is raised if connect is not done.
+           self.missings will be set to missings downloaded
+
+        :target_dir: (str) target dir
+        :pattern: (str) regex that will be used to compile the pattern
+        :processes: (str) number of processes to run in parallel. Default use all available
+        """
+        if processes is None:
+            self.nb_process = multiprocessing.cpu_count()
+        else:
+            self.nb_process = processes
+        self.missings = []
+        if self.auth is None:
+            raise RuntimeError(("AsfCherryPick:cherry_pick_all called "
+                                "but auth not set. Call the connect method "
+                                "before calling the cherry_pick_all one"))
+        parameters = []
+        for url in self.urls:
+            parameters.append((url, target_dir, pattern))
+        if processes == 1:
+            for parameter in parameters:
+                self.cherry_pick(parameter)
+        else:
+            with Pool(processes=processes) as pool:
+                pool.map(self.cherry_pick, parameters)
+
+    def cherry_pick(self, parameters):
+        """download data from parameters. parameters is a tuple containing
+            an url, a taraget_dir and a pattern.
+        """
+        url, target_dir, pattern = parameters
+        re_pattern = re.compile(pattern)
+        my_missings = []
+        with remotezip.RemoteZip(url, session=self.auth) as zip:
+            for zip_info in zip.infolist():
+                if re_pattern.search(str(zip_info.filename)):
+                    logger.info(f'extracting {zip_info.filename}')
+                    target = target_dir / Path(zip_info.filename)
+                    if target.exists():
+                        logger.info(f"{target} exists, skipping download")
+                        continue
+                    try:
+                        zip.extract(zip_info.filename, path=self.tempdir)
+                    except Exception as excpt:
+                        logger.warning(f"Fail to extract {target}: {excpt}")
+                        my_missings.append((url, target))
+                        continue
+                    temp_filename = self.tempdir / zip_info.filename
+                    if not target.parent.exists():
+                        target.parent.mkdir(parents=True, exist_ok=True)
+                    temp_filename.rename(target)
+        return my_missings
+
+
+def get_roi_from_kml(kml_filename, padding=None):
+    """Extract region of interest given the kml
+    :returns:(list) bounding box as a list of (lon, lat) tuples
+    """
+    res = []
+    with open(kml_filename) as kml_file:
+        doc = kml_file.read().encode('utf-8')
+    k = kml.KML()
+    k.from_string(doc)
+    for feature0 in k.features():
+        print("{}, {}".format(feature0.name, feature0.description))
+        for feature1 in feature0.features():
+            logger.debug(f"found feature: {feature1}")
+            if isinstance(feature1.geometry, geometry.Polygon):
+                polygon = feature1.geometry
+                res = [(x[0], x[1]) for x in polygon.exterior.coords]
+    logger.info(f"polygon found before padding: {res}")
+    if padding is not None:
+        min_lat = min([x[1] for x in res])
+        max_lat = max([x[1] for x in res])
+        for idx, val in enumerate(res):
+            if val[1] == min_lat:
+                res[idx] = (res[idx][0], res[idx][1] - padding)
+                continue
+            if val[1] == max_lat:
+                res[idx] = (res[idx][0], res[idx][1] + padding)
+        logger.info(f"polygon found after padding of {padding} on lat. {res}")
+    return res
+
+
+def read_auth(filename):
+    """ reads filename that contains authentification
+    file is a text file with on line, containing login and password
+    separated by a space.
+
+    :param filename: the file that contains the credential
+    :type filename: str
+    :return: login,password
+    :rtype: tuple
+    """
+    try:
+        with open(filename, "r") as _f:
+            (login, password) = _f.readline().split(' ')
+            if password.endswith('\n'):
+                password = password[:-1]
+    except Exception as excpt:
+        logger.critical(f"cannot read file {filename}: {excpt}")
+        raise Exception(f"read_auth raised  {excpt}")
+    return (login, password)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="extract coordinate from kml and query asf to get elements matching the pattern")
+    group = parser.add_mutually_exclusive_group(required=True)
+
+    group.add_argument("--kml", type=str, help="input is a kml file. Geographic search")
+    group.add_argument("--safelist", type=str,
+                       help="input is a text file containing safe names")
+    group.add_argument("--urls", type=str, help="input is a text file containing urls pointing to zip files")
+    group.add_argument("--granules", type=str, help="input is a coma separated list of granule, e.g. safe name without .SAFE extension")
+    parser.add_argument("-c", type=str,
+                        help=("(str) file containing asf user credentials: "
+                              "format: one line of the form user password"))
+    parser.add_argument("-d", type=str, default='2014-09-01:2022-06-01',
+                        help="(str) date range in the format. Default=%(default)s")
+    parser.add_argument("-j", type=int, default=1,
+                        help="(int) number of download to do in parallel, default=%(default)s")
+    parser.add_argument("-m", type=float, default=0.3,
+                        help="(float) adding a margin on the latitute as found in the xml. default=%(default)s")
+    parser.add_argument("-o", type=str, default=None, help="(str) relative orbit number in the form of D041")
+    parser.add_argument("-p", type=str, default='(manifest.safe|s1.*xml$)',
+                        help='(str) regex for patterns. Default=%(default)s')
+    parser.add_argument("-t", type=str, default='SAFES', help="(str) target dir. Default=%(default)s")
+    parser.add_argument("--saveproducts", type=str, default=None,
+                        help="(str) if set, filename in which we want to write the set of url found")
+    parser.add_argument("-H", action="store_true",
+                        help="provide more detailed help")
+    parser.add_argument("-v", type=int, default=3,
+                        help=("set logging level:"
+                              "0 critical, 1 error, 2 warning,"
+                              "3 info, 4 debug, default=info"))
+    if "-H" in sys.argv:
+        print(__doc__)
+
+        sys.exit(0)
+
+    args = parser.parse_args()
+    logging_translate = [logging.CRITICAL, logging.ERROR, logging.WARNING,
+                         logging.INFO, logging.DEBUG]
+    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                        level=logging_translate[args.v])
+
+    script_base_name = Path(__file__).name
+    logger = logging.getLogger(script_base_name + ":main")
+    cmd_line = ' '.join(sys.argv)
+    logger.info(f"called as {cmd_line}")
+
+    user, passwd = read_auth(args.c)
+
+    target_dir = Path(args.t)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    picker = AsfCherryPick()
+    if args.kml is not None:
+        orbit = args.o
+        if orbit is None:
+            logger.error("orbit should be provided when searching using kml")
+            sys.exit(1)
+        if orbit[0] != 'A' and orbit[0] != 'D':
+            logger.error(('wrong format for relative orbit. Should be of the form'
+                          f'D0041 or A0034, got {args.o}'))
+            sys.exit(1)
+        roi = get_roi_from_kml(args.kml, padding=args.m)
+        if len(roi) == 0:
+            logger.error("Cannot extract region interest from kml, aborting")
+            sys.exit(1)
+        logger.info(f"Extracted region of interest (lon,lat, alt): {roi}")
+        picker.search_urls(roi, orbit, args.d.split(":")[0], args.d.split(":")[1])
+    if args.urls is not None:
+        with open(args.urls, "r") as _url:
+            refs_url = [line.strip() for line in _url]
+            picker.urls = refs_url
+    if args.granules or args.safelist:
+        refs_products = []
+        if args.granules:
+            refs_products = args.granules.split(",")
+        if args.safelist:
+            with open(args.safelist, "r") as _url:
+                refs_products = [line.strip() for line in _url]
+        search_results = asf.granule_search(refs_products)
+        refs_url = []
+        for product in search_results:
+            product_dict = product.geojson()
+            if product_dict['properties']['url'].endswith(".zip"):
+                refs_url.append(product_dict['properties']['url'])
+        picker.urls = refs_url
+    logger.info(f"fetching urls: {picker.urls}")
+    if args.saveproducts is not None:
+        with open(args.saveproducts, "w") as _urls:
+            for url in picker.urls:
+                _urls.write(f"{url}\n")
+    picker.connect(user, passwd)
+    picker.cherry_pick_all(target_dir, args.p, args.j)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

asf_cherry_pick/get_missings.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+
+"""
+Does a diff between two sets to check missing elements.
+Basically makes the same as the comm command.
+
+Sets are built either from a filename or as a list of elements in a directory.
+
+If input are not formated in the same way, user can provide a regex to select
+the elements that will be compared.
+
+
+Examples:
+
+=========
+
+Suppose file D041_urls.txt contains lines like
+
+https://datapool.asf.alaska.edu/SLC/SA/S1A_IW_SLC__1SDV_20220523T123454_20220523T123520_043338_052CE2_EDD3.zip
+https://datapool.asf.alaska.edu/SLC/SA/S1A_IW_SLC__1SDV_20220523T123429_20220523T123456_043338_052CE2_6C68.zip
+https://datapool.asf.alaska.edu/SLC/SA/S1A_IW_SLC__1SDV_20220523T123404_20220523T123431_043338_052CE2_5FAF.zip
+
+and directory SAFE_D041 contains directories like
+SAFE_D041/S1A_IW_SLC__1SDV_20220523T123454_20220523T123520_043338_052CE2_EDD3.SAFE
+SAFE_D041/S1A_IW_SLC__1SDV_20170218T123330_20170218T123357_015338_01926D_76B4.SAFE
+SAFE_D041/S1A_IW_SLC__1SDV_20170218T123355_20170218T123422_015338_01926D_3DDE.SAFE
+SAFE_D041/S1A_IW_SLC__1SDV_20170218T123420_20170218T123452_015338_01926D_787F.SAFE
+SAFE_D041/S1A_IW_SLC__1SDV_20170302T123330_20170302T123357_015513_0197BE_2F8E.SAFE
+
+Looking at the first lines we want to match the
+S1A_IW_SLC__1SDV_20220523T123454_20220523T123520_043338_052CE2_EDD3
+
+We provide the script with two inputs (input a and input b). For each input, we need to provide
+if we will list a director or a file. Finally we need to provide a pattern to match. Pattern
+will follow the python regex. The first set of parenthesis define the part that will be
+compared.
+
+The script will output all the patterns that are in a and not in b. The last option allows the
+user to add a prefix (option -P) and a suffix (option -S) to the found names
+
+Here is a full example:
+
+get_missings.py           # name of the script
+-a D041_urls.txt          # input a
+-ta f                     # type of a is f, ie a file
+-b SAFE_D041              # input b
+-tb d                     # type of b is a directory
+-pa '.*/(.*).zip'         # pattern of a: skip all everything up to the last /
+                          # then grab everything up to pattern .zip
+-pb 'SAFE_D041/(.*).SAFE' # grab everything after SAFE_D041/ up to .SAFE
+-P 'https://datapool.asf.alaska.edu/SLC/SA/' -S '.zip'
+
+"""
+
+# classical imports
+import argparse
+import logging
+# import numpy as np
+from pathlib import Path
+import sys
+import re
+
+# import matplotlib.pyplot as plt
+# if "GDAL_SYS" in os.environ and os.environ["GDAL_SYS"] == 'True':
+#    from osgeo import gdal
+# else:
+#    import nsbas.gdal as gdal
+# gdal.UseExceptions()
+
+logger = logging.getLogger(__name__)
+
+def filter(str_list, pattern):
+    for elem in str_list:
+        m = pattern.search(elem)
+        if m:
+            yield m[1]
+
+def get_matching_dirs(directory, pattern):
+    str_dirs = [str(x) for x in directory.glob("*")]
+    res = set(filter(str_dirs, pattern))
+    return res
+
+def get_matching_lines(filename, pattern):
+    res = set()
+    with open(filename) as _f:
+        res = set(filter(_f.readlines(), pattern))
+    return res
+
+def main():
+    parser = argparse.ArgumentParser(description="extract missing data from a target list, given a directory where fetched data lies")
+    parser.add_argument("-a", type=str,
+                        help="(str) input set a")
+    parser.add_argument("-ta", type=str, choices=['f', 'd'],
+                        help="(str) type of the input 1, f(ile), d(irectory)")
+    parser.add_argument("-b", type=str,
+                        help="(str) input set b")
+    parser.add_argument("-tb", type=str, choices=['f', 'd'],
+                        help="(str) type of the input 2, f(ile), d(irectory)")
+    parser.add_argument("-pa", type=str,
+                        help="(str, regex) pattern for input 1")
+    parser.add_argument("-pb", type=str,
+                        help="(str, regex) pattern for input 2")
+    parser.add_argument("-P", type=str, default="",
+                        help="Prefix to use when printing the missing elems")
+    parser.add_argument("-S", type=str, default="",
+                        help="Suffix to use when printing the missing elems")
+    parser.add_argument("-H", action="store_true",
+                        help="provide more detailed help")
+    parser.add_argument("-v", type=int, default=3,
+                        help=("set logging level:"
+                              "0 critical, 1 error, 2 warning,"
+                              "3 info, 4 debug, default=info"))
+    if "-H" in sys.argv:
+        print(__doc__)
+        sys.exit(0)
+    args = parser.parse_args()
+    logging_translate = [logging.CRITICAL, logging.ERROR, logging.WARNING,
+                         logging.INFO, logging.DEBUG]
+    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                        level=logging_translate[args.v])
+    script_base_name = Path(__file__).name
+    logger = logging.getLogger(script_base_name + ":main")
+    cmd_line = ' '.join(sys.argv)
+    logger.info(f"called as {cmd_line}")
+    input_1 = args.a
+    input_2 = args.b
+    pattern1 = re.compile(args.pa)
+    pattern2 = re.compile(args.pb)
+    if args.ta == "d":
+        path_1 = Path(input_1)
+        input_1_set = get_matching_dirs(path_1, pattern1)
+    else:
+        input_1_set = get_matching_lines(input_1, pattern1)
+    if args.tb == "d":
+        path_2 = Path(input_2)
+        input_2_set = get_matching_dirs(path_2, pattern2)
+    else:
+        input_2_set = get_matching_lines(input_2, pattern2)
+    missings = input_1_set - input_2_set
+    for elem in missings:
+        print(f"{args.P}{elem}{args.S}")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

asf_cherry_pick-2.0.2.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: asf_cherry_pick
+Version: 2.0.2
+Summary: Python package for cherry picking Data into asf
+Author-email: Franck Thollard <franck.thollard@univ-grenoble-alpes.fr>
+License: BSD 3-Clause License
+Project-URL: Homepage, https://gricad-gitlab.univ-grenoble-alpes.fr/NSBAS/asf_cherry_pick
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: asf_search==9.0.9
+Requires-Dist: fastkml
+Requires-Dist: lxml
+Requires-Dist: remotezip>=0.10.0
+Dynamic: license-file
+
+asf_cherry_pick
+===============
+
+The Alaska Sar Fundation mirrors the sentinel1 data from the ESA. For a given acquisition, 
+data are provided as a zip file. 
+
+We provide here a script (and an API) that can fetch data into the zip file, allowing to
+download only the product of interest. This is useflull either for downloading meta data 
+or only the tiff file of interest (e.g. only one polarization and one sub swath). 
+
+Elements to fetch are describe as a pattern (in the sens of regular expression). 
+
+The set of product are given either 
+
+- a file in kml format (that contains a polygon which represent the region of interest)
+- a file containing the list of zip files to fetch 
+- a file containing the list of urls
+
+Installation
+------------
+
+- Unzip the file.
+- create a virtual env environment (e.g. python3 -m venv asf_cherry_pick)
+- go to the directory in asf_cherry_pick where the setup.py lies
+- run the command **pip install .**
+
+Upon installation, you will have access to the script asf_cherry_pick. 
+
+Run **asf_cherry_pick -h** and **asf_cherry_pick -H** for a more detail help. 
+
+Enjoy. 
+

asf_cherry_pick-2.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+asf_cherry_pick/__init__.py,sha256=6s-y4LgO0iMCJ1ndkouqoy0vecB543VTMqrPltuD6vI,88
+asf_cherry_pick/asf_cherry_pick.py,sha256=PJpCeIolO5oGoi0Cd1UNHYuXtj9ZvVGbR6BzDbj5Svs,14107
+asf_cherry_pick/get_missings.py,sha256=GGLYPb5LCFBKFUZYwku2JUt3G1LNdXTLDMGFRqAyuos,5702
+asf_cherry_pick-2.0.2.dist-info/licenses/LICENSE,sha256=I84XAs8yECtU2yvR8QrGJ4ZW-lXVZ0PU7iQHKZD_NfE,1062
+asf_cherry_pick-2.0.2.dist-info/METADATA,sha256=zv49-5nhly39dYUzqC5UOfFlFAjtK3gNi-4cLLjyj2Q,1809
+asf_cherry_pick-2.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+asf_cherry_pick-2.0.2.dist-info/entry_points.txt,sha256=tEXrqQCteE0acnGdSp9cIrBGFXojvN57p3037FmJrlw,122
+asf_cherry_pick-2.0.2.dist-info/top_level.txt,sha256=qIAGZxWljXrIFeALnvuh64D3nb9ZIc4I300sapAVSNg,16
+asf_cherry_pick-2.0.2.dist-info/RECORD,,

asf_cherry_pick-2.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

asf_cherry_pick-2.0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+asf_cherry_pick = asf_cherry_pick.asf_cherry_pick:main
+get_missings = asf_cherry_pick.get_missings:main

asf_cherry_pick-2.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 NSBAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

asf_cherry_pick-2.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+asf_cherry_pick