pywmdr 0.2.dev4__py3-none-any.whl → 0.2.dev5__py3-none-any.whl

pywmdr/__init__.py

@@ -28,6 +28,7 @@ import click
 from pywmdr.ets import ets
 from pywmdr.bundle import bundle
 from pywmdr.util import get_package_version
+from pywmdr.migrations import migrate
 
 __version__ = get_package_version()
 
@@ -40,3 +41,4 @@ def cli():
 
 cli.add_command(bundle)
 cli.add_command(ets)
+cli.add_command(migrate)

pywmdr/cli_options.py

@@ -25,6 +25,13 @@ import sys
 import click
 
 
+OPTION_OUTPUT = click.option(
+    '--output',
+    '-o',
+    type=click.File('w', encoding='utf-8'),
+    help='Name of output file')
+
+
 def OPTION_VERBOSITY(f):
     logging_options = ['ERROR', 'WARNING', 'INFO', 'DEBUG']
 

pywmdr/migrations.py

@@ -0,0 +1,417 @@
+##############################################################################
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+###############################################################################
+
+import datetime
+import json
+import logging
+import re
+
+from lxml import etree
+
+import click
+
+from pywmdr import cli_options
+from pywmdr.util import urlopen_
+
+LOGGER = logging.getLogger(__name__)
+
+NAMESPACES = {
+    'gmd': 'http://www.isotc211.org/2005/gmd',
+    'gco': 'http://www.isotc211.org/2005/gco',
+    'gml': 'http://www.opengis.net/gml/3.2',
+    'om': 'http://www.opengis.net/om/2.0',
+    'wmdr': 'http://def.wmo.int/wmdr/2017',
+    'xlink': 'http://www.w3.org/1999/xlink'
+}
+
+
+def xpath_(node: etree.Element, xpath: str) -> str | None:
+    """
+    Helper function to derive a value from an XPath
+
+    :param node: `etree.Element`
+    :param xpath: `str` of XPath expression
+
+    :returns: `str` of matching XPath value or `None`
+    """
+
+    try:
+        val = node.xpath(xpath, namespaces=NAMESPACES)[0]
+        if hasattr(val, 'text'):  # node
+            return val.text
+        else:  # attribute
+            return val
+    except IndexError:
+        return None
+
+
+class Migration:
+    def __init__(self, record: str):
+        """
+        Initializer
+
+        :param record: `str` of WMDR1 XML record
+
+        :returns: `pywmdr.migrations.Migration`
+        """
+
+        self.record = record
+        self.warnings = []
+
+    def migrate(self) -> dict:
+        """
+        Migrate a WMDR1 XML to WMDR2
+
+        :returns: `dict` of WMDR2
+        """
+
+        created = datetime.datetime.now(datetime.UTC).strftime(
+            '%Y-%m-%dT%H:%M:%SZ').replace('+00:00', 'Z')
+
+        wmdr2 = {
+            'id': None,
+            'type': 'Feature',
+            'conformsTo': ['http://wigos.wmo.int/spec/wmdr/2/conf/core'],
+            'time': None,
+            'geometry': None,
+            'properties': {
+                'type': 'facility',
+                'created': created,
+                'contacts': []
+            },
+            'links': []
+        }
+
+        if isinstance(self.record, str):
+            record_ = self.record.encode('utf-8')
+        elif isinstance(self.record, bytes):
+            record_ = self.record
+
+        tree = etree.fromstring(record_)
+
+        facility = tree.xpath('//wmdr:facility', namespaces=NAMESPACES)[0]
+
+        val = xpath_(facility, './/wmdr:ObservingFacility/gml:identifier')
+        wmdr2['id'] = val
+
+        val = xpath_(facility, './/wmdr:geospatialLocation//gml:Point/gml:pos')
+
+        if val is not None:
+            coordinates = [float(x) for x in val.split()]
+            wmdr2['geometry'] = {
+                'type': 'Point',
+                'coordinates': [coordinates[1], coordinates[0]]
+            }
+            if len(coordinates) == 3:
+                wmdr2['geometry']['coordinates'].append(coordinates[2])
+
+        val = xpath_(facility, './/wmdr:ObservingFacility/gml:name')
+        wmdr2['properties']['title'] = val
+
+        val = xpath_(facility, './/wmdr:ObservingFacility/wmdr:description//wmdr:description')  # noqa
+        if val is not None:
+            wmdr2['properties']['description'] = val
+
+        val = xpath_(facility, './/wmdr:facilityType/@xlink:href')
+        wmdr2['properties']['facilityType'] = {
+            'id': val.split('/')[-1],
+            'url': val
+        }
+
+        val = xpath_(facility, './/wmdr:wmoRegion/@xlink:href')
+        if val is not None:
+            wmdr2['properties']['wmoRegion'] = {
+                'id': val.split('/')[-1],
+                'url': val
+            }
+        else:
+            wmdr2['properties']['wmoRegion'] = {
+                'id': 'unknown',
+                'url': 'http://codes.wmo.int/wmdr/WMORegion/unknown'
+            }
+
+        val = xpath_(facility, './/wmdr:dateEstablished')
+        wmdr2['time'] = {
+            'interval': [val]
+        }
+
+        val = xpath_(facility, './/wmdr:dateClosed')
+        if val is not None:
+            wmdr2['time']['interval'].append(val)
+        else:
+            wmdr2['time']['interval'].append('..')
+
+        for ci_rp in tree.xpath('//gmd:CI_ResponsibleParty', namespaces=NAMESPACES):  # noqa
+            contact2 = self.ci_responsibleparty_to_contact(ci_rp)
+            if contact2 is not None:
+                wmdr2['properties']['contacts'].append(contact2)
+
+        if not wmdr2['properties']['contacts']:
+            wmdr2['properties'].pop('contacts')
+            if contact2 is not None:
+                wmdr2['properties']['contacts'].append(contact2)
+
+        for link in facility.xpath('.//wmdr:onlineResource//gmd:URL', namespaces=NAMESPACES):  # noqa
+            wmdr2['links'].append({
+                'rel': 'related',
+                'href': link.text
+            })
+
+        territories = tree.xpath('//wmdr:territory', namespaces=NAMESPACES)
+        if territories:
+            wmdr2['properties']['territories'] = []
+            for territory in territories:
+                territory_ = {}
+                territory_name = xpath_(
+                    territory, './/wmdr:territoryName/@xlink:href')
+
+                if territory_name is not None:
+                    territory_['territory'] = {
+                        'id': territory_name.split('/')[-1],
+                        'url': territory_name
+                    }
+                    begin = xpath_(
+                        territory, './/wmdr:validPeriod//gml:beginPosition')
+
+                    territory_['dates'] = [begin]
+
+                    end = xpath_(territory, './/wmdr:validPeriod//gml:endPosition')  # noqa
+
+                    if end is None:
+                        territory_['dates'].append('..')
+                    else:
+                        territory_['dates'].append(end)
+                    wmdr2['properties']['territories'].append(territory_)
+
+        observations = tree.xpath('//wmdr:observation/wmdr:ObservingCapability', namespaces=NAMESPACES)  # noqa
+
+        if observations:
+            wmdr2['properties']['observations'] = []
+
+            for observation in observations:
+                observation_ = {
+                    'programAffiliations': [],
+                    'configurations': []
+                }
+                observed_geometry = xpath_(
+                    observation, './/om:type/@xlink:href')
+
+                if observed_geometry is not None:
+                    observation_['observedGeometry'] = {
+                        'id': observed_geometry.split('/')[-1],
+                        'url': observed_geometry
+                    }
+
+                observed_property = xpath_(
+                    observation, './/om:observedProperty/@xlink:href')
+
+                observation_['observedProperty'] = {
+                    'id': observed_property.split('/')[-1],
+                    'url': observed_property
+                }
+
+                program_affiliations = observation.xpath(
+                    './wmdr:programAffiliation/@xlink:href',
+                    namespaces=NAMESPACES)
+                if program_affiliations:
+                    for program_affiliation in program_affiliations:
+                        observation_['programAffiliations'].append({
+                            'programAffiliation': {
+                                'id': program_affiliation.split('/')[-1],
+                                'url': program_affiliation
+                             }})
+
+                deployments = observation.xpath(
+                    './/wmdr:Deployment', namespaces=NAMESPACES)
+
+                for deployment in deployments:
+                    configuration_ = {
+                        'id': None,
+                        'time': {
+                            'interval': []
+                        }
+                    }
+                    configuration_['id'] = xpath_(deployment, './/@gml:id')
+
+                    begin = xpath_(
+                        deployment, './/wmdr:validPeriod//gml:beginPosition')
+
+                    configuration_['time']['interval'].append(begin)
+
+                    end = xpath_(
+                        deployment, './/wmdr:validPeriod//gml:endPosition')
+
+                    if end is None:
+                        configuration_['time']['interval'].append('..')
+                    else:
+                        configuration_['time']['interval'].append(end)
+
+                    observing_method = xpath_(
+                        deployment, './/wmdr:observingMethod/@xlink:href')
+                    if observing_method is not None:
+                        configuration_['observingMethod'] = {
+                            'id': observing_method.split('/')[-1],
+                            'url': observing_method
+                        }
+
+                    observation_['configurations'].append(configuration_)
+
+                if not observation_['configurations']:
+                    msg = f"No configurations found for observation ({observation_['observedProperty']['url']})"  # noqa
+                    self.warnings.append(msg)
+                    observation_.pop('configurations')
+
+                wmdr2['properties']['observations'].append(observation_)
+
+        wmdr2['links'].append({
+            'rel': 'original',
+            'type': 'application/xml',
+            'title': f"{wmdr2['properties']['title']} as WMDR1",
+            'href': f"https://oscar.wmo.int/oai/provider?verb=GetRecord&metadataPrefix=wmdr&identifier={wmdr2['id']}"  # noqa
+        })
+
+        return wmdr2
+
+
+    def ci_responsibleparty_to_contact(self, node: etree.Element) -> tuple[dict, list[str]]:  # noqa
+        """
+        Helper function to transform ISO gmd:CI_ResponsibleParty to a
+        WMDR2 contact
+
+        :param node: `etree.Element` of gmd:CI_ResponsibleParty
+
+        :returns: `dict` of WMDR2 contact object, or `None`
+        """
+
+        val = None
+        contact = {}
+
+        val = xpath_(node, './/gmd:role/gmd:CI_RoleCode/@codeListValue')
+        if val is None:
+            LOGGER.debug('No role found; skipping')
+            return
+        else:
+            contact['roles'] = [val]
+
+        val = xpath_(node, './/gmd:individualName/gco:CharacterString')
+        if val is not None:
+            contact['name'] = val
+
+        val = xpath_(node, './/gmd:organisationName/gco:CharacterString')
+        if val is not None:
+            contact['organization'] = val
+
+        phones = node.xpath('.//gmd:voice/gco:CharacterString',
+                            namespaces=NAMESPACES)
+        if phones:
+            contact['phones'] = []
+            for phone in phones:
+                contact['phones'].append({'value': phone.text})
+
+        emails = node.xpath('.//gmd:electronicMailAddress/gco:CharacterString',
+                            namespaces=NAMESPACES)
+        if emails:
+            contact['emails'] = []
+            for email in emails:
+                # validate we have email address
+                # (something at something dot something, no white space)
+                email_valid = re.fullmatch(r'[^@\s]+@[^@\s]+\.[^@\s]+', email.text) is not None  # noqa
+                email_address = email.text.strip()
+                if not email_valid:
+                    msg = f'Invalid email: {email_address}'
+                    self.warnings.append(msg)
+                contact['emails'].append({'value': email_address})
+
+        val = xpath_(node, './/gmd:contactInstructions/gco:CharacterString')
+        if val is not None:
+            contact['contactInstructions'] = val
+
+        try:
+            val = node.xpath('.//gmd:address', namespaces=NAMESPACES)[0]
+        except IndexError:
+            val = None
+
+        if val is not None:
+            address = {}
+
+            val2 = xpath_(val, './/gmd:deliveryPoint/gco:CharacterString')
+            if val2 is not None:
+                address['deliveryPoint'] = [val2]
+
+            val2 = xpath_(val, './/gmd:city/gco:CharacterString')
+            if val2 is not None:
+                address['city'] = val2
+
+            val2 = xpath_(val, './/gmd:postalCode/gco:CharacterString')
+            if val2 is not None:
+                address['postalCode'] = val2
+
+            val2 = xpath_(val, './/gmd:country/gco:CharacterString')
+            if val2 is not None:
+                address['country'] = val2
+
+            val2 = xpath_(val, './/gmd:onlineResource//gmd:URL')
+            if val2 is not None:
+                address['links'] = [{
+                    'href': val2
+                }]
+
+            if address:
+                contact['addresses'] = [address]
+
+        return contact
+
+
+@click.command()
+@click.pass_context
+@click.argument('file_or_url')
+@cli_options.OPTION_OUTPUT
+@cli_options.OPTION_VERBOSITY
+def migrate(ctx, file_or_url, output, verbosity):
+    """migrate a WMDR1 record to WMDR2 core"""
+
+    click.echo(f'Opening {file_or_url}')
+
+    if file_or_url.startswith('http'):
+        content = urlopen_(file_or_url).read()
+    else:
+        with open(file_or_url) as fh:
+            content = fh.read()
+
+    click.echo(f'Migrating {file_or_url} from WMDR1 to WMDR2')
+
+    try:
+        m = Migration(content)
+        content = m.migrate()
+        if output is not None:
+            json.dump(content, output, indent=4)
+        else:
+            click.echo(json.dumps(content, indent=4))
+
+        if m.warnings:
+            click.echo('\nWARNINGS:')
+            for w in m.warnings:
+                click.echo(f'- {w}')
+    except Exception as err:
+        import traceback
+        print(traceback.format_exc())
+        raise click.ClickException(err)
+        ctx.exit(1)

pywmdr/pygeoapi_plugin.py

@@ -37,11 +37,18 @@
 #     processor:
 #         name: pywmdr.pygeoapi_plugin.WMDR2ETSProcessor
 #
+# pywmdr-wmdr2-migrate:
+#     type: process
+#     processor:
+#         name: pywmdr.pygeoapi_plugin.WMDR1toWMDR2Processor
+#
+#
 # 3. (re)start pygeoapi
 #
 # The resulting processes will be available at the following endpoints:
 #
 # /processes/pywmdr-record-validate
+# /processes/pywmdr-wmdr2-migrate
 #
 # Note that pygeoapi's OpenAPI/Swagger interface (at /openapi) will also
 # provide a developer-friendly interface to test and run requests
@@ -52,6 +59,8 @@ import logging
 
 from pygeoapi.process.base import BaseProcessor, ProcessorExecuteError
 
+from pywmdr.bundle import WMDR2_FILES
+from pywmdr.migrations import Migration
 from pywmdr.wmdr2.ets import WMDR2TestSuite
 from pywmdr.util import get_package_version, THISDIR, urlopen_
 
@@ -63,6 +72,11 @@ with (THISDIR / 'resources' / 'ets-report.json').open() as fh:
 with (THISDIR / 'resources' / '0-20008-0-THE.json').open() as fh:
     EXAMPLE_WMDR2 = json.load(fh)
 
+with (THISDIR / 'resources' / '0-20000-0-87582.xml').open() as fh:
+    EXAMPLE_WMDR1 = fh.read()
+
+with (WMDR2_FILES / 'wmdr2-bundled.json').open() as fh:
+    WMDR2_SCHEMA = json.load(fh)
 
 PROCESS_WMDR2_ETS = {
     'version': get_package_version(),
@@ -113,6 +127,55 @@ PROCESS_WMDR2_ETS = {
 }
 
 
+PROCESS_MIGRATE = {
+    'version': get_package_version(),
+    'id': 'pywmdr-wmdr2-migrate',
+    'title': {
+        'en': 'WMDR1 to WMDR2 migration utility'
+    },
+    'description': {
+        'en': 'Migrate a WMDR1 XML into WMDR2'
+    },
+    'keywords': ['wigos', 'wmdr2', 'wmdr1', 'migrate', 'metadata'],
+    'links': [{
+        'type': 'text/html',
+        'rel': 'about',
+        'title': 'information',
+        'href': 'https://github.com/wmo-im/wmdr2',
+        'hreflang': 'en-US'
+    }],
+    'jobControlOptions': ['sync-execute', 'async-execute'],
+    'inputs': {
+        'record': {
+            'title': 'WMD1 record',
+            'description': 'WMDR1 record (can be inline or remote link)',
+            'schema': {
+                'type': ['object', 'string']
+            },
+            'minOccurs': 1,
+            'maxOccurs': 1,
+            'metadata': None,
+            'keywords': ['wmdr1']
+        }
+    },
+    'outputs': {
+        'result': {
+            'title': 'WMDR1 to WMDR2 migration result',
+            'description': 'WMDR1 to WMDR2 migration result',
+            'schema': {
+                'contentMediaType': 'application/geo+json',
+                **WMDR2_SCHEMA
+            }
+        }
+    },
+    'example': {
+        'inputs': {
+            'record': EXAMPLE_WMDR2
+        }
+    }
+}
+
+
 class WMDR2ETSProcessor(BaseProcessor):
     """WMDR2 ETS"""
 
@@ -151,3 +214,43 @@ class WMDR2ETSProcessor(BaseProcessor):
 
     def __repr__(self):
         return '<WMDR2ETSProcessor>'
+
+
+class WMDR2MigrateProcessor(BaseProcessor):
+    """Migrate processor"""
+
+    def __init__(self, processor_def):
+        """
+        Initialize object
+
+        :param processor_def: provider definition
+
+        :returns: pywmdr.pygeoapi_plugin.WMDR2MigrateProcessor
+        """
+
+        super().__init__(processor_def, PROCESS_MIGRATE)
+
+    def execute(self, data, outputs=None):
+
+        response = None
+        mimetype = 'application/json'
+        record = data.get('record')
+
+        if record is None:
+            msg = 'Missing record'
+            LOGGER.error(msg)
+            raise ProcessorExecuteError(msg)
+
+        if isinstance(record, str) and record.startswith('http'):
+            LOGGER.debug('Record is a link')
+            record = json.loads(urlopen_(record).read())
+        else:
+            LOGGER.debug('Record is inline')
+
+        LOGGER.debug('Running ETS against record')
+        response = Migration(record).migrate()
+
+        return mimetype, response
+
+    def __repr__(self):
+        return '<WMDR2MigrateProcessor>'

{pywmdr-0.2.dev4.dist-info → pywmdr-0.2.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywmdr
-Version: 0.2.dev4
+Version: 0.2.dev5
 Summary: A Python implementation of the test suite for WIGOS Metadata Record
 Author-email: Tom Kralidis <tomkralidis@gmail.com>
 Maintainer-email: Tom Kralidis <tomkralidis@gmail.com>
@@ -23,6 +23,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: click
 Requires-Dist: jsonschema
+Requires-Dist: lxml
 Requires-Dist: rfc3339-validator
 Requires-Dist: rfc3987
 Requires-Dist: shapely
@@ -95,6 +96,15 @@ pywmdr ets validate https://example.org/path/to/file.json --verbosity DEBUG
 
 # write results to logfile
 pywmdr ets validate https://example.org/path/to/file.json --verbosity DEBUG --logfile /tmp/foo.txt
+
+# migrate WMDR1 to WMDR2 (file on disk)
+pywmdr migrate /path/to/file.xml --verbosity DEBUG
+
+# migrate WMDR1 to WMDR2 (URL)
+pywmdr migrate https://example.org/path/to/file.xml --verbosity DEBUG
+
+# migrate WMDR1 to WMDR2 (URL), write results to file
+pywmdr migrate https://example.org/path/to/file.xml --output file.json
 ```
 
 ## Using the API

{pywmdr-0.2.dev4.dist-info → pywmdr-0.2.dev5.dist-info}/RECORD

@@ -1,18 +1,19 @@
-pywmdr/__init__.py,sha256=nmM2-nevDwLyTfthzuef-AJ8kMnWxX7Nb_gMXJ3ZL00,1318
+pywmdr/__init__.py,sha256=O_2G6cZKo3-Y8bupQ3NUaF35TxS9urMDRxWD0CN6AeA,1381
 pywmdr/bundle.py,sha256=VgkDwwsftqbpBXKJORwjzl6oqST5LVB-6K0vCKOZRqo,3190
-pywmdr/cli_options.py,sha256=N70OlGeonJvkVNdDoh-X606J1JCUWnKwpa5gduoJ_aM,1533
+pywmdr/cli_options.py,sha256=BCNGnzm525keOj8UpKnXnhtunfBiNmdcuGtXGoq1iz8,1667
 pywmdr/codelists.py,sha256=UMYqy4Tk8GLulqMjE3xouZMWCUpnW1qHbuwZ1CiACpA,3694
 pywmdr/errors.py,sha256=Uu2J6vmTjaWuNJaW-mtdZ_KCztc9x4wjaLRVDZP6Lk0,1176
 pywmdr/ets.py,sha256=I1JeheXMCsPtRXjf5ay8I3MZFrrsDtj5k0XT68XCOOY,2076
-pywmdr/pygeoapi_plugin.py,sha256=5XrLF1OF8l8-2fiMSSuZe41s9cryQEsfgkckO8zJ2fc,4500
+pywmdr/migrations.py,sha256=FxhJYLQE6_BXLpEMZAWQRu1nIGDBGlt88HkcpbPWUwc,14328
+pywmdr/pygeoapi_plugin.py,sha256=Ls6PqsVgfPNzcWS-ff7jZOxhLTSc9CjyPL6lgXgMRPo,7286
 pywmdr/util.py,sha256=LE_Ds6OuG7vNQxjFQcogWiPD5CNQyHhqIXeW6TNXJZE,2639
 pywmdr/resources/0-20008-0-THE.json,sha256=luAjCrxbnwq4x0nwqm2vyx8d5rXmkMeGwVCQ2w-gaXg,5873
 pywmdr/resources/ets-report.json,sha256=VwZohaD_EloSlwhYXxnj08Z3ckfbFYudLc2dWwxvlus,2243
 pywmdr/wmdr2/__init__.py,sha256=VK88WG3wpt5RqksGgutMnr02OhUlksWcoAnoeSRRWic,1035
 pywmdr/wmdr2/ets.py,sha256=8M5zyubMfiQvArl_-LoGlH8dhDiY-fIAmkIsub-N3JM,7817
-pywmdr-0.2.dev4.dist-info/licenses/LICENSE.md,sha256=Q8E0TXZpH75ydPcip7DXr21Y3uwJNgQUFv3ipMXwPkw,839
-pywmdr-0.2.dev4.dist-info/METADATA,sha256=aNycYCK2jFNpRNEQlaH_4yP3Q5NkCxNm2CgW8yS9C0o,5104
-pywmdr-0.2.dev4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-pywmdr-0.2.dev4.dist-info/entry_points.txt,sha256=Ga7GlkDlThWwprQDc5OawyWtV_RT9FXilgXjwKacynU,38
-pywmdr-0.2.dev4.dist-info/top_level.txt,sha256=_Zdw0CS7tVYk-CJZmu9xEqIzOuY98RsI6CUMh8Kh818,7
-pywmdr-0.2.dev4.dist-info/RECORD,,
+pywmdr-0.2.dev5.dist-info/licenses/LICENSE.md,sha256=Q8E0TXZpH75ydPcip7DXr21Y3uwJNgQUFv3ipMXwPkw,839
+pywmdr-0.2.dev5.dist-info/METADATA,sha256=1sCFM6Zi6au4wNJ9HKV1HwAZERDHYYb_k0ar6ND_FSM,5444
+pywmdr-0.2.dev5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pywmdr-0.2.dev5.dist-info/entry_points.txt,sha256=Ga7GlkDlThWwprQDc5OawyWtV_RT9FXilgXjwKacynU,38
+pywmdr-0.2.dev5.dist-info/top_level.txt,sha256=_Zdw0CS7tVYk-CJZmu9xEqIzOuY98RsI6CUMh8Kh818,7
+pywmdr-0.2.dev5.dist-info/RECORD,,