sarkit-convert 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

sarkit_convert/terrasar.py

@@ -19,7 +19,7 @@ import datetime
 import pathlib
 
 import dateutil.parser
-import lxml.builder
+import lxml.etree
 import numpy as np
 import numpy.linalg as npl
 import numpy.polynomial.polynomial as npp
@@ -27,7 +27,6 @@ import sarkit.sicd as sksicd
 import sarkit.verification
 import sarkit.wgs84
 import scipy.constants
-from lxml import etree
 
 from sarkit_convert import __version__
 from sarkit_convert import _utils as utils
@@ -59,10 +58,6 @@ def _parse_to_naive(timestamp_str):
     return dateutil.parser.parse(timestamp_str).replace(tzinfo=None)
 
 
-def _naive_to_sicd_str(timestamp):
-    return timestamp.replace(tzinfo=None).isoformat() + "Z"
-
-
 def _boolstr_to_bool(text):
     return text in ("1", "true")
 
@@ -603,44 +598,45 @@ def cosar_to_sicd(
     antenna_array_gain[0, 0] = 0.0
 
     # Build XML
-    sicd = lxml.builder.ElementMaker(
-        namespace=NSMAP["sicd"], nsmap={None: NSMAP["sicd"]}
+    sicd_xml_obj = lxml.etree.Element(
+        f"{{{NSMAP['sicd']}}}SICD", nsmap={None: NSMAP["sicd"]}
     )
-    sicd_xml_obj = sicd.SICD()
     sicd_ew = sksicd.ElementWrapper(sicd_xml_obj)
 
-    sicd_ew["CollectionInfo"] = sicd.CollectionInfo(
-        sicd.CollectorName(collector_name),
-        sicd.CoreName(core_name),
-        sicd.CollectType("MONOSTATIC"),
-        sicd.RadarMode(sicd.ModeType(radar_mode_type), sicd.ModeID(radar_mode_id)),
-        sicd.Classification(classification),
-    )
-    sicd_ew["ImageCreation"] = sicd.ImageCreation(
-        sicd.Application(creation_application),
-        sicd.DateTime(_naive_to_sicd_str(creation_time)),
-    )
-    sicd_ew["ImageData"] = sicd.ImageData(
-        sicd.PixelType(COSAR_PIXEL_TYPE),
-        sicd.NumRows(str(num_rows)),
-        sicd.NumCols(str(num_cols)),
-        sicd.FirstRow(str(first_row)),
-        sicd.FirstCol(str(first_col)),
-        sicd.FullImage(sicd.NumRows(str(num_rows)), sicd.NumCols(str(num_cols))),
-        sicd.SCPPixel(sicd.Row(str(scp_pixel[0])), sicd.Col(str(scp_pixel[1]))),
-    )
-
-    def make_xyz(arr):
-        return [sicd.X(str(arr[0])), sicd.Y(str(arr[1])), sicd.Z(str(arr[2]))]
-
-    def make_llh(arr):
-        return [sicd.Lat(str(arr[0])), sicd.Lon(str(arr[1])), sicd.HAE(str(arr[2]))]
-
-    # Will add ImageCorners later
-    sicd_ew["GeoData"] = sicd.GeoData(
-        sicd.EarthModel("WGS_84"),
-        sicd.SCP(sicd.ECF(*make_xyz(scp_ecf)), sicd.LLH(*make_llh(scp_llh))),
-    )
+    sicd_ew["CollectionInfo"] = {
+        "CollectorName": collector_name,
+        "CoreName": core_name,
+        "CollectType": "MONOSTATIC",
+        "RadarMode": {
+            "ModeType": radar_mode_type,
+            "ModeID": radar_mode_id,
+        },
+        "Classification": classification,
+    }
+    sicd_ew["ImageCreation"] = {
+        "Application": creation_application,
+        "DateTime": creation_time,
+    }
+    sicd_ew["ImageData"] = {
+        "PixelType": COSAR_PIXEL_TYPE,
+        "NumRows": num_rows,
+        "NumCols": num_cols,
+        "FirstRow": first_row,
+        "FirstCol": first_col,
+        "FullImage": {
+            "NumRows": num_rows,
+            "NumCols": num_cols,
+        },
+        "SCPPixel": scp_pixel,
+    }
+
+    sicd_ew["GeoData"] = {
+        "EarthModel": "WGS_84",
+        "SCP": {
+            "ECF": scp_ecf,
+            "LLH": scp_llh,
+        },
+    }
 
     dc_sgn = np.sign(-doppler_rate_poly[0, 0])
     col_deltakcoa_poly = (
@@ -665,44 +661,41 @@ def cosar_to_sicd(
     col_window_name = proc_param.findtext("./azimuthWindowID")
     col_window_coeff = float(proc_param.findtext("./azimuthWindowCoefficient"))
 
-    sicd_ew["Grid"] = sicd.Grid(
-        sicd.ImagePlane("SLANT"),
-        sicd.Type("RGZERO"),
-        sicd.TimeCOAPoly(),
-        sicd.Row(
-            sicd.UVectECF(*make_xyz(u_row)),
-            sicd.SS(str(spacings[0])),
-            sicd.ImpRespWid(str(row_wid)),
-            sicd.Sgn("-1"),
-            sicd.ImpRespBW(str(row_bw)),
-            sicd.KCtr(str(center_frequency / (scipy.constants.speed_of_light / 2))),
-            sicd.DeltaK1(str(-row_bw / 2)),
-            sicd.DeltaK2(str(row_bw / 2)),
-            sicd.DeltaKCOAPoly(),
-            sicd.WgtType(
-                sicd.WindowName(row_window_name),
-                sicd.Parameter({"name": "COEFFICIENT"}, str(row_window_coeff)),
-            ),
-        ),
-        sicd.Col(
-            sicd.UVectECF(*make_xyz(u_col)),
-            sicd.SS(str(spacings[1])),
-            sicd.ImpRespWid(str(col_wid)),
-            sicd.Sgn("-1"),
-            sicd.ImpRespBW(str(col_bw)),
-            sicd.KCtr("0"),
-            sicd.DeltaK1(str(dk1)),
-            sicd.DeltaK2(str(dk2)),
-            sicd.DeltaKCOAPoly(),
-            sicd.WgtType(
-                sicd.WindowName(col_window_name),
-                sicd.Parameter({"name": "COEFFICIENT"}, str(col_window_coeff)),
-            ),
-        ),
-    )
-    sicd_ew["Grid"]["TimeCOAPoly"] = time_coa_poly
-    sicd_ew["Grid"]["Row"]["DeltaKCOAPoly"] = [[0]]
-    sicd_ew["Grid"]["Col"]["DeltaKCOAPoly"] = col_deltakcoa_poly
+    sicd_ew["Grid"] = {
+        "ImagePlane": "SLANT",
+        "Type": "RGZERO",
+        "TimeCOAPoly": time_coa_poly,
+        "Row": {
+            "UVectECF": u_row,
+            "SS": spacings[0],
+            "ImpRespWid": row_wid,
+            "Sgn": -1,
+            "ImpRespBW": row_bw,
+            "KCtr": center_frequency / (scipy.constants.speed_of_light / 2),
+            "DeltaK1": -row_bw / 2,
+            "DeltaK2": row_bw / 2,
+            "DeltaKCOAPoly": [[0.0]],
+            "WgtType": {
+                "WindowName": row_window_name,
+                "Parameter": [("COEFFICIENT", str(row_window_coeff))],
+            },
+        },
+        "Col": {
+            "UVectECF": u_col,
+            "SS": spacings[1],
+            "ImpRespWid": col_wid,
+            "Sgn": -1,
+            "ImpRespBW": col_bw,
+            "KCtr": 0.0,
+            "DeltaK1": dk1,
+            "DeltaK2": dk2,
+            "DeltaKCOAPoly": col_deltakcoa_poly,
+            "WgtType": {
+                "WindowName": col_window_name,
+                "Parameter": [("COEFFICIENT", str(col_window_coeff))],
+            },
+        },
+    }
     rcs_row_sf = None
     rcs_col_sf = None
     if row_window_name == "Hamming":
@@ -720,84 +713,104 @@ def cosar_to_sicd(
         sicd_ew["Grid"]["Col"]["ImpRespWid"] = col_wid
         rcs_col_sf = 1 + np.var(wgts) / np.mean(wgts) ** 2
 
-    sicd_ew["Timeline"] = sicd.Timeline(
-        sicd.CollectStart(_naive_to_sicd_str(collection_start_time)),
-        sicd.CollectDuration(str(collection_duration)),
-        sicd.IPP(
-            {"size": "1"},
-            sicd.Set(
-                {"index": "1"},
-                sicd.TStart(str(0)),
-                sicd.TEnd(str(num_pulses / prf)),
-                sicd.IPPStart(str(0)),
-                sicd.IPPEnd(str(num_pulses - 1)),
-                sicd.IPPPoly(),
-            ),
-        ),
-    )
-    sicd_ew["Timeline"]["IPP"]["Set"][0]["IPPPoly"] = [0, prf]
+    sicd_ew["Timeline"] = {
+        "CollectStart": collection_start_time,
+        "CollectDuration": collection_duration,
+        "IPP": {
+            "@size": 1,
+            "Set": [
+                {
+                    "@index": 1,
+                    "TStart": 0,
+                    "TEnd": num_pulses / prf,
+                    "IPPStart": 0,
+                    "IPPEnd": num_pulses - 1,
+                    "IPPPoly": [0, prf],
+                }
+            ],
+        },
+    }
 
     sicd_ew["Position"]["ARPPoly"] = apc_poly
 
-    rcv_channels = sicd.RcvChannels(
-        {"size": str(len(tx_rcv_pols))},
-    )
+    chan_parameters = []
     for ndx, tx_rcv_pol in enumerate(tx_rcv_pols):
-        rcv_channels.append(
-            sicd.ChanParameters(
-                {"index": str(ndx + 1)}, sicd.TxRcvPolarization(tx_rcv_pol)
-            )
+        chan_parameters.append(
+            {
+                "@index": ndx + 1,
+                "TxRcvPolarization": tx_rcv_pol,
+            }
         )
 
-    sicd_ew["RadarCollection"] = sicd.RadarCollection(
-        sicd.TxFrequency(sicd.Min(str(tx_freq_min)), sicd.Max(str(tx_freq_max))),
-        sicd.Waveform(
-            {"size": "1"},
-            sicd.WFParameters(
-                {"index": "1"},
-                sicd.TxPulseLength(str(tx_pulse_length)),
-                sicd.TxRFBandwidth(str(tx_rf_bw)),
-                sicd.TxFreqStart(str(tx_freq_start)),
-                sicd.TxFMRate(str(tx_fm_rate)),
-                sicd.RcvWindowLength(str(rcv_window_length)),
-                sicd.ADCSampleRate(str(adc_sample_rate)),
-            ),
-        ),
-        sicd.TxPolarization(tx_polarization),
-        rcv_channels,
-    )
+    sicd_ew["RadarCollection"] = {
+        "TxFrequency": {
+            "Min": tx_freq_min,
+            "Max": tx_freq_max,
+        },
+        "Waveform": {
+            "@size": 1,
+            "WFParameters": [
+                {
+                    "@index": 1,
+                    "TxPulseLength": tx_pulse_length,
+                    "TxRFBandwidth": tx_rf_bw,
+                    "TxFreqStart": tx_freq_start,
+                    "TxFMRate": tx_fm_rate,
+                    "RcvWindowLength": rcv_window_length,
+                    "ADCSampleRate": adc_sample_rate,
+                }
+            ],
+        },
+        "TxPolarization": tx_polarization,
+        "RcvChannels": {
+            "@size": len(tx_rcv_pols),
+            "ChanParameters": chan_parameters,
+        },
+    }
     if len(tx_polarizations) > 1:
         sicd_ew["RadarCollection"]["TxPolarization"] = "SEQUENCE"
-        tx_sequence = sicd.TxSequence({"size": str(len(tx_polarizations))})
+        tx_steps = []
         for ndx, tx_pol in enumerate(tx_polarizations):
-            tx_sequence.append(
-                sicd.TxStep({"index": str(ndx + 1)}, sicd.TxPolarization(tx_pol))
+            tx_steps.append(
+                {
+                    "@index": ndx + 1,
+                    "TxPolarization": tx_pol,
+                }
             )
-        rcv_channels.addprevious(tx_sequence)
+        sicd_ew["RadarCollection"]["TxSequence"] = {
+            "@size": len(tx_polarizations),
+            "TxStep": tx_steps,
+        }
 
     now = (
         datetime.datetime.now(datetime.timezone.utc)
         .isoformat(timespec="microseconds")
         .replace("+00:00", "Z")
     )
-    sicd_ew["ImageFormation"] = sicd.ImageFormation(
-        sicd.RcvChanProc(sicd.NumChanProc("1"), sicd.ChanIndex(str(chan_index))),
-        sicd.TxRcvPolarizationProc(tx_rcv_polarization),
-        sicd.TStartProc(str(0)),
-        sicd.TEndProc(str(collection_duration)),
-        sicd.TxFrequencyProc(
-            sicd.MinProc(str(tx_freq_min)), sicd.MaxProc(str(tx_freq_max))
-        ),
-        sicd.ImageFormAlgo("RMA"),
-        sicd.STBeamComp(st_beam_comp),
-        sicd.ImageBeamComp("SV"),
-        sicd.AzAutofocus("NO"),
-        sicd.RgAutofocus("NO"),
-        sicd.Processing(
-            sicd.Type(f"sarkit-convert {__version__} @ {now}"),
-            sicd.Applied("true"),
-        ),
-    )
+    sicd_ew["ImageFormation"] = {
+        "RcvChanProc": {
+            "NumChanProc": 1,
+            "ChanIndex": [chan_index],
+        },
+        "TxRcvPolarizationProc": tx_rcv_polarization,
+        "TStartProc": 0,
+        "TEndProc": collection_duration,
+        "TxFrequencyProc": {
+            "MinProc": tx_freq_min,
+            "MaxProc": tx_freq_max,
+        },
+        "ImageFormAlgo": "RMA",
+        "STBeamComp": st_beam_comp,
+        "ImageBeamComp": "SV",
+        "AzAutofocus": "NO",
+        "RgAutofocus": "NO",
+        "Processing": [
+            {
+                "Type": f"sarkit-convert {__version__} @ {now}",
+                "Applied": True,
+            },
+        ],
+    }
 
     sicd_ew["Antenna"]["TwoWay"]["XAxisPoly"] = ant_x_dir_poly
     sicd_ew["Antenna"]["TwoWay"]["YAxisPoly"] = ant_y_dir_poly
@@ -809,20 +822,17 @@ def cosar_to_sicd(
         dtype=float, shape=(1, 1)
     )
 
-    sicd_ew["RMA"] = sicd.RMA(
-        sicd.RMAlgoType("OMEGA_K"),
-        sicd.ImageType("INCA"),
-        sicd.INCA(
-            sicd.TimeCAPoly(),
-            sicd.R_CA_SCP(str(scp_rca)),
-            sicd.FreqZero(str(center_frequency)),
-            sicd.DRateSFPoly(),
-            sicd.DopCentroidPoly(),
-        ),
-    )
-    sicd_ew["RMA"]["INCA"]["TimeCAPoly"] = time_ca_poly
-    sicd_ew["RMA"]["INCA"]["DRateSFPoly"] = drsf_poly
-    sicd_ew["RMA"]["INCA"]["DopCentroidPoly"] = doppler_centroid_poly
+    sicd_ew["RMA"] = {
+        "RMAlgoType": "OMEGA_K",
+        "ImageType": "INCA",
+        "INCA": {
+            "TimeCAPoly": time_ca_poly,
+            "R_CA_SCP": scp_rca,
+            "FreqZero": center_frequency,
+            "DRateSFPoly": drsf_poly,
+            "DopCentroidPoly": doppler_centroid_poly,
+        },
+    }
 
     sicd_ew["SCPCOA"] = sksicd.compute_scp_coa(sicd_xml_obj.getroottree())
 
@@ -849,28 +859,19 @@ def cosar_to_sicd(
         1e-2,
     )
 
-    radiometric = sicd.Radiometric(
-        sicd.NoiseLevel(sicd.NoiseLevelType("ABSOLUTE"), sicd.NoisePoly()),
-        sicd.SigmaZeroSFPoly(),
-        sicd.BetaZeroSFPoly(),
-        sicd.GammaZeroSFPoly(),
-    )
-    sksicd.Poly2dType().set_elem(
-        radiometric.find("./{*}NoiseLevel/{*}NoisePoly"), noise_poly
-    )
-    sksicd.Poly2dType().set_elem(
-        radiometric.find("./{*}SigmaZeroSFPoly"), sigmazero_poly
-    )
-    sksicd.Poly2dType().set_elem(radiometric.find("./{*}BetaZeroSFPoly"), betazero_poly)
-    sksicd.Poly2dType().set_elem(
-        radiometric.find("./{*}GammaZeroSFPoly"), gammazero_poly
-    )
+    sicd_ew["Radiometric"] = {
+        "NoiseLevel": {
+            "NoiseLevelType": "ABSOLUTE",
+            "NoisePoly": noise_poly,
+        },
+        "SigmaZeroSFPoly": sigmazero_poly,
+        "BetaZeroSFPoly": betazero_poly,
+        "GammaZeroSFPoly": gammazero_poly,
+    }
+
     if rcs_row_sf and rcs_col_sf:
         rcssf_poly = betazero_poly * (rcs_row_sf * rcs_col_sf / (row_bw * col_bw))
-        radiometric.find("./{*}SigmaZeroSFPoly").addprevious(sicd.RCSSFPoly())
-        sksicd.Poly2dType().set_elem(radiometric.find("./{*}RCSSFPoly"), rcssf_poly)
-
-    sicd_xml_obj.find("./{*}Antenna").addprevious(radiometric)
+        sicd_ew["Radiometric"]["RCSSFPoly"] = rcssf_poly
 
     # Add Geodata Corners
     sicd_xmltree = sicd_xml_obj.getroottree()
@@ -890,13 +891,12 @@ def cosar_to_sicd(
     sicd_ew["GeoData"]["ImageCorners"] = icp_llh[:, :2]
 
     # Add RNIIRS
-    xml_helper = sksicd.XmlHelper(sicd_xmltree)
-    inf_density, pred_rniirs = utils.get_rniirs_estimate(xml_helper)
+    inf_density, pred_rniirs = utils.get_rniirs_estimate(sicd_ew)
     sicd_ew["CollectionInfo"].add(
         "Parameter", ("INFORMATION_DENSITY", f"{inf_density:.2g}")
     )
     sicd_ew["CollectionInfo"].add(
-        "Parameter", ("PREDICTED_RNIIRS", f"{pred_rniirs:.2g}")
+        "Parameter", ("PREDICTED_RNIIRS", f"{pred_rniirs:.1f}")
     )
 
     # Validate XML
@@ -961,7 +961,7 @@ def main(args=None):
     if not config.input_xml_file.is_file():
         raise ValueError(f"Input XML file {str(config.input_xml_file)} is not a file")
 
-    tsx_xml = etree.parse(config.input_xml_file).getroot()
+    tsx_xml = lxml.etree.parse(config.input_xml_file).getroot()
 
     images = dict()
     img_ndx = 1

{sarkit_convert-0.2.0.dist-info → sarkit_convert-0.3.1.dist-info}/METADATA

@@ -1,37 +1,40 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sarkit-convert
-Version: 0.2.0
+Version: 0.3.1
 Summary: Python library for converting SAR data to standard formats.
 Author-Email: Valkyrie Systems Corporation <info@govsco.com>
-License: MIT
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Scientific/Engineering
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3.14
+Project-URL: Repository, https://github.com/ValkyrieSystems/sarkit-convert.git
+Project-URL: Bug Tracker, https://github.com/ValkyrieSystems/sarkit-convert/issues
+Project-URL: Changelog, https://github.com/ValkyrieSystems/sarkit-convert/blob/main/CHANGELOG.md
+Requires-Python: >=3.12
 Requires-Dist: lxml>=5.1.0
-Requires-Dist: numpy>=1.26.3
-Requires-Dist: pyproj>=3.7.2
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pyproj>=3.6.1
 Requires-Dist: sarkit>=1.3.0
-Requires-Dist: scipy>=1.15.1
+Requires-Dist: scipy>=1.13.0
 Provides-Extra: iceye
-Requires-Dist: h5py>=3.12.1; extra == "iceye"
+Requires-Dist: h5py>=3.11.0; extra == "iceye"
 Requires-Dist: python-dateutil>=2.9.0; extra == "iceye"
 Provides-Extra: cosmo
 Requires-Dist: astropy>=6.0.0; extra == "cosmo"
-Requires-Dist: h5py>=3.12.1; extra == "cosmo"
+Requires-Dist: h5py>=3.11.0; extra == "cosmo"
 Requires-Dist: python-dateutil>=2.9.0; extra == "cosmo"
-Requires-Dist: shapely>=2.0.2; extra == "cosmo"
+Requires-Dist: shapely>=2.0.6; extra == "cosmo"
 Provides-Extra: terrasar
 Requires-Dist: python-dateutil>=2.9.0; extra == "terrasar"
 Provides-Extra: sentinel
 Requires-Dist: python-dateutil>=2.9.0; extra == "sentinel"
-Requires-Dist: tifffile>=2025.5.10; extra == "sentinel"
+Requires-Dist: tifffile>=2024.7.2; extra == "sentinel"
 Provides-Extra: all
 Requires-Dist: sarkit-convert[iceye]; extra == "all"
 Requires-Dist: sarkit-convert[cosmo]; extra == "all"
@@ -43,6 +46,13 @@ Description-Content-Type: text/markdown
 
 <img src="https://raw.githubusercontent.com/ValkyrieSystems/sarkit/main/docs/source/_static/sarkit_logo.png" width=200>
 
+[![PyPI - Version](https://img.shields.io/pypi/v/sarkit-convert)](https://pypi.org/project/sarkit-convert/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sarkit-convert)
+[![PyPI - License](https://img.shields.io/pypi/l/sarkit-convert)](./LICENSE)
+[![SPEC 0 — Minimum Supported Dependencies](https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038)](https://scientific-python.org/specs/spec-0000/)
+<br>
+[![Tests](https://github.com/ValkyrieSystems/sarkit-convert/actions/workflows/test.yml/badge.svg)](https://github.com/ValkyrieSystems/sarkit-convert/actions/workflows/test.yml)
+
 </div>
 
 **sarkit-convert** is a Python library for converting SAR data to standard formats.

sarkit_convert-0.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+sarkit_convert-0.3.1.dist-info/METADATA,sha256=zBfO4aQX3Gznxx8GDk4POVag3pvkfJBkPY4kbKIdRa4,3047
+sarkit_convert-0.3.1.dist-info/WHEEL,sha256=Wb0ASbVj8JvWHpOiIpPi7ucfIgJeCi__PzivviEAQFc,90
+sarkit_convert-0.3.1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+sarkit_convert-0.3.1.dist-info/licenses/LICENSE,sha256=H0HxqjXuxJwqg17L2F5jjbrWm5IV-R_FNLbzu-eJEc0,1086
+sarkit_convert/__init__.py,sha256=l_h1XRjbcNc4Hg66LvcjKzjk4lVlwaFLbNizvQtysgo,295
+sarkit_convert/_utils.py,sha256=mZlMqxXDR0we4hAabGpRHeGvVZLnoB6uvjYO-QiuIi0,9233
+sarkit_convert/_version.py,sha256=2KwowXhmiT6-Bln7VPq9d9sRpAzJq9qLyclhp2KWmjA,21
+sarkit_convert/cosmo.py,sha256=JUirYDfrYm4hUDa0ubyL4bOuvW18-MQKOCAADNpWgWU,34531
+sarkit_convert/create_arp_poly.py,sha256=ApntYmMts8jZ7gSfDMDZ64DehvFUdXxIQf-XuBO41fQ,5987
+sarkit_convert/iceye.py,sha256=F5bIh-knTRHHxGksJLOcdqn14PO9OQUlpCMJ7FqyJqQ,27115
+sarkit_convert/sentinel.py,sha256=Ru1jVG5g4VLfNsy5o8uhoPdBvyi6jk8tH6XcE4recXU,60693
+sarkit_convert/sidd_metadata.py,sha256=lVffYbkvGWZ6hQl_PcQfR8FEMcneCGsp5n6xR5ZvHIk,6927
+sarkit_convert/terrasar.py,sha256=iFvZtspMLiPI59rWCqgoAyzBqTsmR0d-RbcxQkh5Lho,34794
+sarkit_convert-0.3.1.dist-info/RECORD,,

{sarkit_convert-0.2.0.dist-info → sarkit_convert-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.6)
+Generator: pdm-backend (2.4.7)
 Root-Is-Purelib: true
 Tag: py3-none-any

sarkit_convert-0.2.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-sarkit_convert-0.2.0.dist-info/METADATA,sha256=SiqX7I3vnXIuaZMPA7yXtV8PeKo2X1li5k98TozI0jM,2185
-sarkit_convert-0.2.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-sarkit_convert-0.2.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-sarkit_convert-0.2.0.dist-info/licenses/LICENSE,sha256=H0HxqjXuxJwqg17L2F5jjbrWm5IV-R_FNLbzu-eJEc0,1086
-sarkit_convert/__init__.py,sha256=l_h1XRjbcNc4Hg66LvcjKzjk4lVlwaFLbNizvQtysgo,295
-sarkit_convert/_utils.py,sha256=bzFGIBE870QAMfEhm5CYAP4PUlY0KM6V3paTng_rr_8,9407
-sarkit_convert/_version.py,sha256=clN3TnyYyt5T_wUJLVBmutS2kYLLBET4JFB2QXnRm2Q,21
-sarkit_convert/cosmo.py,sha256=ttrN0f_pU2PmH3LL0DojWCxxVDAcCm8j6kWB2w82BIU,36374
-sarkit_convert/create_arp_poly.py,sha256=dgbKYYKUarC7W1edbEeozy6O4Gg-u62LsV8v1mrC_hs,5983
-sarkit_convert/iceye.py,sha256=LmOqEo2_BW7noo2I9QJbPMLn51c1tAaItUBomA62gy0,31108
-sarkit_convert/sentinel.py,sha256=s7rrssfrJhLsV90HzKAzoxeYNXNKTru0qNvRNkEfoU8,63124
-sarkit_convert/sidd_metadata.py,sha256=lVffYbkvGWZ6hQl_PcQfR8FEMcneCGsp5n6xR5ZvHIk,6927
-sarkit_convert/terrasar.py,sha256=Rl7BfBt2ZTQ9sVlMWY-rgLp0RBoWwBT1PWymSCW8Xvk,36351
-sarkit_convert-0.2.0.dist-info/RECORD,,