pynmrstar 3.3.5__cp312-cp312-macosx_10_13_x86_64.whl

pynmrstar/schema.py

@@ -0,0 +1,367 @@
+import decimal
+import logging
+import os
+import re
+from csv import DictReader
+from datetime import date
+from functools import lru_cache
+from io import StringIO
+from typing import Union, List, Optional, Any, Dict, IO
+
+from pynmrstar import definitions, utils
+from pynmrstar._internal import _interpret_file
+
+logger = logging.getLogger('pynmrstar')
+
+
+class Schema(object):
+    """A BMRB schema. Used to validate NMR-STAR files. Unless you need to
+       choose a specific schema version, PyNMR-STAR will automatically load
+       a schema for you. If you do need a specific schema version, you can
+       create an object of this class and then pass it to the methods
+       which allow the specification of a schema. """
+
+    def __init__(self, schema_file: Union[str, IO] = None) -> None:
+        """Initialize a BMRB schema. With no arguments the most
+        up-to-date schema will be fetched from the BMRB FTP site.
+        Otherwise pass a URL or a file to load a schema from using the
+        schema_file keyword argument."""
+
+        self.headers: List[str] = []
+        self.schema: Dict[str, Dict[str, str]] = {}
+        self.schema_order: List[str] = []
+        self.category_order: List[str] = []
+        self.version: str = "unknown"
+        self.data_types: Dict[str, str] = {}
+
+        # Try loading from the internet first
+        if schema_file is None:
+            schema_file = definitions.SCHEMA_URL
+        self.schema_file = schema_file
+
+        # Get whatever schema they specified, wrap in StringIO and pass that to the csv reader
+        schema_stream = _interpret_file(schema_file)
+        fix_newlines = StringIO('\n'.join(schema_stream.read().splitlines()))
+
+        csv_reader_instance = DictReader(fix_newlines)
+        self.headers = csv_reader_instance.fieldnames
+
+        # Skip the header descriptions and header index values and anything
+        #  else before the real data starts
+        tmp_line = next(csv_reader_instance)
+        try:
+            while tmp_line['Dictionary sequence'] != "TBL_BEGIN":
+                tmp_line = next(csv_reader_instance)
+        except IndexError:
+            raise ValueError(f"Could not parse a schema from the specified URL: {schema_file}")
+        self.version = tmp_line['ADIT category view type']
+
+        for line in csv_reader_instance:
+
+            if line['Dictionary sequence'] == "TBL_END":
+                break
+
+            single_tag_data: Dict[str, any] = dict(line)
+
+            # Convert nulls
+            if single_tag_data['Nullable'] == "NOT NULL":
+                single_tag_data['Nullable'] = False
+            else:
+                single_tag_data['Nullable'] = True
+            if '' in single_tag_data:
+                del single_tag_data['']
+
+            self.schema[single_tag_data['Tag'].lower()] = single_tag_data
+            self.schema_order.append(single_tag_data['Tag'])
+            formatted = utils.format_category(single_tag_data['Tag'])
+            if formatted not in self.category_order:
+                self.category_order.append(formatted)
+
+        try:
+            # Read in the data types
+            types_file = _interpret_file(os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                                      "reference_files/data_types.csv"))
+        except IOError:
+            # Load the data types from Github if we can't find them locally
+            try:
+                types_file = _interpret_file(definitions.TYPES_URL)
+            except Exception:
+                raise ValueError("Could not load the data type definition file from disk or the internet!")
+
+        csv_reader_instance = DictReader(types_file, fieldnames=['type_name', 'type_definition'])
+        for item in csv_reader_instance:
+            self.data_types[item['type_name']] = f"^{item['type_definition']}$"
+
+    def __repr__(self) -> str:
+        """Return how we can be initialized."""
+
+        return f"pynmrstar.Schema(schema_file='{self.schema_file}') version {self.version}"
+
+    def __str__(self) -> str:
+        """Print the schema that we are adhering to."""
+
+        return self.string_representation()
+
+    def add_tag(self, tag: str, tag_type: str, null_allowed: bool, sf_category: str, loop_flag: bool,
+                after: str = None):
+        """ Adds the specified tag to the tag dictionary. You must provide:
+
+        1) The full tag as such:
+            "_Entry_interview.Sf_category"
+        2) The tag type which is one of the following:
+            "INTEGER"
+            "FLOAT"
+            "CHAR(len)"
+            "VARCHAR(len)"
+            "TEXT"
+            "DATETIME year to day"
+        3) A python True/False that indicates whether null values are allowed.
+        4) The sf_category of the parent saveframe.
+        5) A True/False value which indicates if this tag is a loop tag.
+        6) Optional: The tag to order this tag behind when normalizing
+           saveframes."""
+
+        # Add the underscore preceding the tag
+        if tag[0] != "_":
+            tag = "_" + tag
+
+        # See if the tag is already in the schema
+        if tag.lower() in self.schema:
+            raise ValueError("Cannot add a tag to the schema that is already in"
+                             f" the schema: {tag}")
+
+        # Check the tag type
+        tag_type = tag_type.upper()
+        if tag_type not in ["INTEGER", "FLOAT", "TEXT", "DATETIME year to day"]:
+            if tag_type.startswith("CHAR(") or tag_type.startswith("VARCHAR("):
+                # This will allow things through that have extra junk on the end, but in general it is
+                # okay to be forgiving as long as we can guess what they mean.
+                length = tag_type[tag_type.index("(") + 1:tag_type.index(")")]
+                # Check the length for non-numbers and 0
+                try:
+                    1 / int(length)
+                except (ValueError, ZeroDivisionError):
+                    raise ValueError(f"Illegal length specified in tag type: {length}")
+
+                # Cut off anything that might be at the end
+                tag_type = tag_type[0:tag_type.index(")") + 1]
+            else:
+                raise ValueError("The tag type you provided is not valid. Please use a type as specified in the help "
+                                 "for this method.")
+
+        # Check the null allowed
+        if str(null_allowed).lower() == "false":
+            null_allowed = False
+        if str(null_allowed).lower() == "true":
+            null_allowed = True
+        if not (null_allowed is True or null_allowed is False):
+            raise ValueError("Please specify whether null is allowed with True/False")
+
+        # Check the category
+        if not sf_category:
+            raise ValueError("Please provide the sf_category of the parent saveframe.")
+
+        # Check the loop flag
+        if loop_flag is not True and loop_flag:
+            raise ValueError("Invalid loop_flag. Please specify True or False.")
+
+        # Conditionally check the tag to insert after
+        new_tag_pos = len(self.schema_order)
+        if after is not None:
+            try:
+                # See if the tag with caps exists in the order
+                new_tag_pos = self.schema_order.index(after) + 1
+            except ValueError:
+                try:
+                    # See if the tag in lowercase exists in the order
+                    new_tag_pos = [x.lower() for x in
+                                   self.schema_order].index(after.lower()) + 1
+                except ValueError:
+                    raise ValueError("The tag you specified to insert this tag after does not exist in the schema.")
+        else:
+            # Determine a sensible place to put the new tag
+            search = utils.format_category(tag.lower())
+            for pos, stag in enumerate([x.lower() for x in self.schema_order]):
+                if stag.startswith(search):
+                    new_tag_pos = pos + 1
+
+        # Add the new tag to the tag order and tag list
+        self.schema_order.insert(new_tag_pos, tag)
+        self.category_order.insert(new_tag_pos, "_" + utils.format_tag(tag))
+
+        # Calculate up the 'Dictionary Sequence' based on the tag position
+        new_tag_pos = (new_tag_pos - 1) * 10
+
+        def _test_pos(position, schema) -> int:
+            for item in schema.schema.values():
+                if float(item["Dictionary sequence"]) == position:
+                    return _test_pos(position + 1, schema)
+            return position
+
+        new_tag_pos = _test_pos(new_tag_pos, self)
+
+        self.schema[tag.lower()] = {"Data Type": tag_type, "Loopflag": loop_flag,
+                                    "Nullable": null_allowed, "public": "Y",
+                                    "SFCategory": sf_category, "Tag": tag,
+                                    "Dictionary sequence": new_tag_pos}
+
+    @lru_cache(maxsize=1024, typed=True)
+    def convert_tag(self, tag: str, value: Any) -> \
+            Optional[Union[str, int, decimal.Decimal, date]]:
+        """ Converts the provided tag from string to the appropriate
+        type as specified in this schema."""
+
+        # If we don't know what the tag is, just return it
+        if tag.lower() not in self.schema:
+            if tag != '_internal.use':
+                logger.warning(f"Couldn't convert tag data type because it is not in the dictionary: {tag}")
+            return value
+
+        full_tag = self.schema[tag.lower()]
+
+        # Get the type
+        value_type, null_allowed = full_tag["Data Type"], full_tag["Nullable"]
+
+        # Check for null
+        if value in definitions.NULL_VALUES:
+            return None
+
+        # Keep strings strings
+        if "CHAR" in value_type or "VARCHAR" in value_type or "TEXT" in value_type:
+            return value
+
+        # Convert ints
+        if "INTEGER" in value_type:
+            try:
+                return int(value)
+            except (ValueError, TypeError):
+                raise ValueError("Could not parse the file because a value that should be an INTEGER is not. Either "
+                                 f"do not specify convert_data_types or fix the file. Tag: '{tag}'.")
+
+        # Convert floats
+        if "FLOAT" in value_type:
+            try:
+                # If we used int() we would lose the precision
+                return decimal.Decimal(value)
+            except (decimal.InvalidOperation, TypeError):
+                raise ValueError("Could not parse the file because a value that should be a FLOAT is not. Either "
+                                 f"do not specify convert_data_types or fix the file. Tag: '{tag}'.")
+
+        if "DATETIME year to day" in value_type:
+            try:
+                year, month, day = [int(x) for x in value.split("-")]
+                return date(year, month, day)
+            except (ValueError, TypeError):
+                raise ValueError("Could not parse the file because a value that should be a DATETIME is not. Please "
+                                 f"do not specify convert_data_types or fix the file. Tag: '{tag}'.")
+
+        # We don't know the data type, so just keep it a string
+        return value
+
+    def string_representation(self, search: bool = None) -> str:
+        """ Prints all the tags in the schema if search is not specified
+        and prints the tags that contain the search string if it is."""
+
+        # Get the longest lengths
+        lengths = [max([len(utils.format_tag(x)) for x in self.schema_order])]
+
+        values = []
+        for key in self.schema.keys():
+            sc = self.schema[key]
+            values.append((sc["Data Type"], sc["Nullable"], sc["SFCategory"], sc["Tag"]))
+
+        for y in range(0, len(values[0])):
+            lengths.append(max([len(str(x[y])) for x in values]))
+
+        text = f"""BMRB schema from: '{self.schema_file}' version '{self.version}'
+{''}
+  {'Tag_Prefix':<{lengths[0]}} {'Tag':<{lengths[1] - 6}} {'Type':<{lengths[2]}} {'Null_Allowed':<{lengths[3]}} {'SF_Category'}
+"""
+        last_tag = ""
+
+        for tag in self.schema_order:
+            # Skip to the next tag if there is a search and it fails
+            if search and search not in tag:
+                continue
+            st = self.schema.get(tag.lower(), None)
+            tag_cat = utils.format_category(tag)
+            if st:
+                if tag_cat != last_tag:
+                    last_tag = tag_cat
+                    text += "\n%-30s\n" % tag_cat
+
+                text += "  %-*s %-*s %-*s  %-*s\n" % (lengths[0], utils.format_tag(tag),
+                                                      lengths[1], st["Data Type"],
+                                                      lengths[2], st["Nullable"],
+                                                      lengths[3], st["SFCategory"])
+
+        return text
+
+    def val_type(self, tag: str, value: Any, category: str = None):
+        """ Validates that a tag matches the type it should have
+        according to this schema."""
+
+        if tag.lower() not in self.schema:
+            return [f"Tag '{tag}' not found in schema."]
+
+        # We will skip type checks for None's
+        is_none = value is None
+
+        # Allow manual specification of conversions for booleans, Nones, etc.
+        if value in definitions.STR_CONVERSION_DICT:
+            if any(isinstance(value, type(x)) for x in definitions.STR_CONVERSION_DICT):
+                value = definitions.STR_CONVERSION_DICT[value]
+
+        # Value should always be string
+        if not isinstance(value, str):
+            value = str(value)
+
+        # Check that it isn't a string None
+        if value in definitions.NULL_VALUES:
+            is_none = True
+
+        # Make local copies of the fields we care about
+        full_tag = self.schema[tag.lower()]
+        bmrb_type = full_tag["BMRB data type"]
+        val_type = full_tag["Data Type"]
+        null_allowed = full_tag["Nullable"]
+        allowed_category = full_tag["SFCategory"]
+        capitalized_tag = full_tag["Tag"]
+
+        if category is not None:
+            if category != allowed_category:
+                return [f"The tag '{capitalized_tag}' in category '{category}' should be in category "
+                        f"'{allowed_category}'."]
+
+        if is_none:
+            if not null_allowed:
+                return [f"Value cannot be NULL but is: {capitalized_tag}':'{value}'."]
+            return []
+        else:
+            # Don't run these checks on unassigned tags
+            if "CHAR" in val_type:
+                length = int(val_type[val_type.index("(") + 1:val_type.index(")")])
+                if len(str(value)) > length:
+                    return [f"Length of '{len(value)}' is too long for '{val_type}': '{capitalized_tag}':'{value}'."]
+
+            # Check that the value matches the regular expression for the type
+            if not re.match(self.data_types[bmrb_type], str(value)):
+                return [f"Value does not match specification: '{capitalized_tag}':'{value}'.\n"
+                        f"     Type specified: {bmrb_type}\n"
+                        f"     Regular expression for type: '{self.data_types[bmrb_type]}'"]
+
+        # Check the tag capitalization
+        if tag != capitalized_tag:
+            return [f"The tag '{tag}' is improperly capitalized but otherwise valid. Should be '{capitalized_tag}'."]
+        return []
+
+    def tag_key(self, x) -> int:
+        """ Helper function to figure out how to sort the tags."""
+
+        try:
+            return self.schema_order.index(x)
+        except ValueError:
+            # Generate an arbitrary sort order for tags that aren't in the
+            #  schema but make sure that they always come after tags in the
+            #   schema
+            return len(self.schema_order) + abs(hash(x))

pynmrstar/utils.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+
+""" This file contains various helper functions."""
+import functools
+import json
+import os
+from typing import Iterable, Any, Dict
+from urllib.error import HTTPError, URLError
+
+from pynmrstar import definitions, cnmrstar, entry as entry_mod
+from pynmrstar._internal import _interpret_file
+from pynmrstar.schema import Schema
+
+# Set this to allow import * from pynmrstar to work sensibly
+__all__ = ['diff', 'format_category', 'format_tag', 'get_schema', 'iter_entries', 'quote_value', 'validate']
+
+
+def diff(entry1: 'entry_mod.Entry', entry2: 'entry_mod.Entry') -> None:
+    """Prints the differences between two entries. Non-equal entries
+    will always be detected, but specific differences detected depends
+    on the order of entries."""
+
+    diffs = entry1.compare(entry2)
+    if len(diffs) == 0:
+        print("Identical entries.")
+    for difference in diffs:
+        print(difference)
+
+
+@functools.lru_cache(maxsize=1024)
+def format_category(tag: str) -> str:
+    """Adds a '_' to the front of a tag (if not present) and strips out
+    anything after a '.'"""
+
+    if tag:
+        if not tag.startswith("_"):
+            tag = "_" + tag
+        if "." in tag:
+            tag = tag[:tag.index(".")]
+    return tag
+
+
+@functools.lru_cache(maxsize=1024)
+def format_tag(tag: str) -> str:
+    """Strips anything before the '.'"""
+
+    if '.' in tag:
+        return tag[tag.index('.') + 1:]
+    return tag
+
+
+@functools.lru_cache(maxsize=1024)
+def format_tag_lc(tag: str) -> str:
+    """Strips anything before the '.' and makes the tag lowercase. """
+
+    return format_tag(tag.lower())
+
+
+# noinspection PyDefaultArgument
+def get_schema(passed_schema: 'Schema' = None, _cached_schema: Dict[str, Schema] = {}) -> 'Schema':
+    """If passed a schema (not None) it returns it. If passed none,
+    it checks if the default schema has been initialized. If not
+    initialized, it initializes it. Then it returns the default schema."""
+
+    if passed_schema:
+        return passed_schema
+
+    if not _cached_schema:
+
+        # Try to load the local file first
+        try:
+            schema_file = os.path.join(os.path.dirname(os.path.realpath(__file__)))
+            schema_file = os.path.join(schema_file, "reference_files/schema.csv")
+            _cached_schema['schema'] = Schema(schema_file=schema_file)
+        except IOError:
+            # Try to load from the internet
+            try:
+                _cached_schema['schema'] = Schema()
+            except (HTTPError, URLError):
+                raise ValueError("Could not load a BMRB schema from the internet or from the local repository.")
+
+    return _cached_schema['schema']
+
+
+def iter_entries(metabolomics: bool = False) -> Iterable['entry_mod.Entry']:
+    """ Returns a generator that will yield an Entry object for every
+        macromolecule entry in the current BMRB database. Perfect for performing
+        an operation across the entire BMRB database. Set `metabolomics=True`
+        in order to get all the entries in the metabolomics database."""
+
+    api_url = f"{definitions.API_URL}/list_entries?database=macromolecules"
+    if metabolomics:
+        api_url = f"{definitions.API_URL}/list_entries?database=metabolomics"
+
+    for entry in json.loads(_interpret_file(api_url).read()):
+        yield entry_mod.Entry.from_database(entry)
+
+
+@functools.lru_cache(maxsize=65536, typed=True)
+def quote_value(value: Any) -> str:
+    """Automatically quotes the value in the appropriate way. Don't
+    quote values you send to this method or they will show up in
+    another set of quotes as part of the actual data. E.g.:
+
+    quote_value('"e. coli"') returns '\'"e. coli"\''
+
+    while
+
+    quote_value("e. coli") returns "'e. coli'"
+
+    This will automatically be called on all values when you use a str()
+    method (so don't call it before inserting values into tags or loops).
+
+    Be mindful of the value of STR_CONVERSION_DICT as it will effect the
+    way the value is converted to a string.
+
+    """
+
+    # Allow manual specification of conversions for booleans, Nones, etc.
+    if value in definitions.STR_CONVERSION_DICT:
+        if any(isinstance(value, type(x)) for x in definitions.STR_CONVERSION_DICT):
+            value = definitions.STR_CONVERSION_DICT[value]
+
+    return cnmrstar.quote_value(value)
+
+
+def validate(entry_to_validate: 'entry_mod.Entry', schema: 'Schema' = None) -> None:
+    """Prints a validation report of an object."""
+
+    validation = entry_to_validate.validate(schema=schema)
+    if len(validation) == 0:
+        print("No problems found during validation.")
+    for pos, err in enumerate(validation):
+        print(f"{pos + 1}: {err}")

pynmrstar-3.3.5.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.

pynmrstar-3.3.5.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: pynmrstar
+Version: 3.3.5
+Summary: PyNMR-STAR provides tools for reading, writing, modifying, and interacting with NMR-STAR files. Maintained by the BMRB.
+Home-page: https://github.com/uwbmrb/PyNMRSTAR
+Author: Jon Wedell
+Author-email: wedell@uchc.edu
+License: MIT
+Keywords: bmrb,parser,nmr,nmrstar,biomagresbank,biological magnetic resonance bank
+Classifier: Development Status :: 6 - Mature
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: requests<=3,>=2.21.0
+
+Welcome to PyNMR-STAR!
+======================================
+
+A Python module for reading, writing, and manipulating NMR-STAR files.
+
+|License| |Wheel| |PythonVersions|
+
+Overview
+--------
+
+This library was developed by the BMRB to give the Python-using NMR
+community tools to work with the NMR-STAR data format. It is used
+internally and is actively maintained. The library is thoroughly
+documented such that calling ``help(object_or_method)`` from an
+interactive python session will print the documentation for the object
+or method. An even more convenient way to learn how to use this library
+is to read the documentation at `read the docs <https://pynmrstar.readthedocs.org>`__.
+
+
+.. |PythonVersions| image:: https://img.shields.io/pypi/pyversions/pynmrstar.svg
+   :target: https://pypi.org/project/PyNMRSTAR
+
+.. |License| image:: https://img.shields.io/pypi/l/pynmrstar.svg
+   :target: https://pypi.org/project/PyNMRSTAR
+
+.. |Wheel| image:: https://img.shields.io/pypi/wheel/pynmrstar.svg
+   :target: https://pypi.org/project/PyNMRSTAR

pynmrstar-3.3.5.dist-info/RECORD

@@ -0,0 +1,19 @@
+cnmrstar.cpython-312-darwin.so,sha256=ZYYrEf-cniAP2ML8TZJ_tQMW7ZQEbWcwfhg0YAq2z58,38160
+pynmrstar/definitions.py,sha256=H4X8POb0CsA9lv8tiLupH0wBzKPdyy5OZCe0A1OqZiU,1510
+pynmrstar/_internal.py,sha256=GNWZPAKI7swRfqndVKamFyATNdNa_3nhocTvzT-fM4Y,12068
+pynmrstar/__init__.py,sha256=z9uQkhmqipDrLHpEk81w7y7HEgepEcKyK7ZWr8YavJA,1967
+pynmrstar/parser.py,sha256=cYnRBkQAdXJU_HY6WCcWMY0Rq2weDyr1hxiWOoQbNfg,15546
+pynmrstar/utils.py,sha256=rd7JkVM9B7gMiveO0RhH6YtoJTB0CUiggsPtSVzmvl8,4662
+pynmrstar/entry.py,sha256=BcwVtSdfcDj4NWzmWvSbwilG9whxTk6CyZUbR15mLBk,46240
+pynmrstar/loop.py,sha256=46vAeXMtKaSovLzFhhiFQCz1nsNqOJPSVpkTTa9tbtg,51892
+pynmrstar/saveframe.py,sha256=5p-_NWi2nEju2FtJG5zm1aSdJrSZi_5lkCMIpTHWXYI,44133
+pynmrstar/exceptions.py,sha256=xJlGbHB_QXMiNWuU_6livAQBMljBuCba50WA_K9pIbc,1449
+pynmrstar/schema.py,sha256=tJsVHkVQR8glvchFBzlRvGDpx2HxS76eucAjR_aKVog,15779
+pynmrstar/reference_files/schema.csv,sha256=BfAJyjfDQaZakdEL5V97dTSDxwgxQZCIp1DeKEhT65w,3694703
+pynmrstar/reference_files/comments.str,sha256=vOGWBs5XU3ddNyROkVOhaPwGb8kx5stoChgo6ICBMio,9942
+pynmrstar/reference_files/data_types.csv,sha256=awbw34Icg16-6epkQLGRM5dEvthcq3hvkgbt6rlZh0I,3432
+pynmrstar-3.3.5.dist-info/RECORD,,
+pynmrstar-3.3.5.dist-info/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
+pynmrstar-3.3.5.dist-info/WHEEL,sha256=kD-LhIT6lUKGukNhSkqq4OnwDJg6bUoeCVUytlUwUF8,111
+pynmrstar-3.3.5.dist-info/top_level.txt,sha256=e5QP9re453LfgZ_mZNGHa7E5HFAXiRoNBPkF1hnn7JQ,19
+pynmrstar-3.3.5.dist-info/METADATA,sha256=DDi4dJhZ0O9p6mWUX2bd72UtKVfKySfqa1uSJEOQRN8,2438

pynmrstar-3.3.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_10_13_x86_64
+

pynmrstar-3.3.5.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cnmrstar
+pynmrstar