pymetkit 1.13.1__tar.gz

pymetkit-1.13.1/AUTHORS

@@ -0,0 +1,12 @@
+metkit authors
+=============
+
+The main development of metkit is done at the European Centre for Medium-Range Weather Forecasts (ECMWF - http://www.ecmwf.int )
+
+Current developers
+==================
+
+Baudouin Raoult
+Tiago Quintino
+Simon Smart
+Matthias Zink

pymetkit-1.13.1/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 1996- ECMWF
+
+   Licensed 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.

pymetkit-1.13.1/NOTICE

@@ -0,0 +1,15 @@
+metkit
+======
+
+Copyright 1996- ECMWF
+
+This product is developed by the
+
+  Development Section, European Centre for Medium-Range Weather Forecasts (ECMWF) - http://www.ecmwf.int
+
+Below is a list of software packages which are used inside:
+
+- No external package in currently included
+
+Please also read the cmake/NOTICE file bundled in the distribution packages, which lists the included third-party CMake macros.
+

pymetkit-1.13.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: pymetkit
+Version: 1.13.1
+Summary: Python interface for metkit
+Author-email: "European Centre for Medium-Range Weather Forecasts (ECMWF)" <software.support@ecmwf.int>
+License: Apache License Version 2.0
+Requires-Python: >=3.10
+License-File: LICENSE
+License-File: NOTICE
+License-File: AUTHORS
+Requires-Dist: cffi
+Requires-Dist: metkitlib
+Requires-Dist: findlibs
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Dynamic: license-file

pymetkit-1.13.1/README.md

@@ -0,0 +1,43 @@
+metkit
+======
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ecmwf/metkit/blob/develop/LICENSE)
+
+Requirements
+------------
+
+Runtime dependencies:
+
+- eckit -- http://github.com/ecmwf/eckit
+
+Build dependencies:
+
+- CMake --- For use and installation see http://www.cmake.org/
+- ecbuild --- ECMWF library of CMake macros ()
+
+Installation
+------------
+
+metkit employs an out-of-source build/install based on CMake.
+
+Make sure ecbuild is installed and the ecbuild executable script is found ( `which ecbuild` ).
+
+Now proceed with installation as follows:
+
+```bash
+# Environment --- Edit as needed
+srcdir=$(pwd)
+builddir=build
+installdir=$HOME/local  
+
+# 1. Create the build directory:
+mkdir $builddir
+cd $builddir
+
+# 2. Run CMake
+ecbuild --prefix=$installdir -- -DECKIT_PATH=<path/to/eckit/install> $srcdir
+
+# 3. Compile / Install
+make -j10
+make install
+```

pymetkit-1.13.1/VERSION

@@ -0,0 +1 @@
+1.13.1

pymetkit-1.13.1/pymetkit.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: pymetkit
+Version: 1.13.1
+Summary: Python interface for metkit
+Author-email: "European Centre for Medium-Range Weather Forecasts (ECMWF)" <software.support@ecmwf.int>
+License: Apache License Version 2.0
+Requires-Python: >=3.10
+License-File: LICENSE
+License-File: NOTICE
+License-File: AUTHORS
+Requires-Dist: cffi
+Requires-Dist: metkitlib
+Requires-Dist: findlibs
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Dynamic: license-file

pymetkit-1.13.1/pymetkit.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+AUTHORS
+LICENSE
+NOTICE
+README.md
+VERSION
+pyproject.toml
+pymetkit.egg-info/PKG-INFO
+pymetkit.egg-info/SOURCES.txt
+pymetkit.egg-info/dependency_links.txt
+pymetkit.egg-info/not-zip-safe
+pymetkit.egg-info/requires.txt
+pymetkit.egg-info/top_level.txt
+python/pymetkit/src/pymetkit/__init__.py
+python/pymetkit/src/pymetkit/_version.py
+python/pymetkit/src/pymetkit/metkit_c.h
+python/pymetkit/src/pymetkit/pymetkit.py

pymetkit-1.13.1/pymetkit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pymetkit-1.13.1/pymetkit.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

pymetkit-1.13.1/pymetkit.egg-info/requires.txt

@@ -0,0 +1,6 @@
+cffi
+metkitlib
+findlibs
+
+[tests]
+pytest

pymetkit-1.13.1/pymetkit.egg-info/top_level.txt

@@ -0,0 +1 @@
+pymetkit

pymetkit-1.13.1/pyproject.toml

@@ -0,0 +1,47 @@
+# pytest
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-vv -s"
+testpaths = [
+    "pymetkit/tests"
+]
+
+# pyproject.toml
+
+[build-system]
+requires = ["setuptools", "wheel", "cffi"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pymetkit"
+description = "Python interface for metkit"
+dynamic = ["version"]
+authors = [
+  { name = "European Centre for Medium-Range Weather Forecasts (ECMWF)", email = "software.support@ecmwf.int" },
+]
+license = { text = "Apache License Version 2.0" }
+requires-python = ">=3.10"
+dependencies = [
+    "cffi",
+    "metkitlib",
+    "findlibs"
+]
+
+[tool.setuptools.dynamic]
+version = { file = ["VERSION"] }
+
+[tool.setuptools]
+packages = ["pymetkit"]
+package-dir = { "pymetkit" = "./python/pymetkit/src/pymetkit" }
+include-package-data = true
+zip-safe = false
+
+[tool.setuptools.package-data]
+"pymetkit" = [
+    "VERSION", 
+    "metkit_c.h"
+]
+
+[project.optional-dependencies]
+tests = ["pytest"]
+

pymetkit-1.13.1/python/pymetkit/src/pymetkit/__init__.py

@@ -0,0 +1 @@
+from .pymetkit import *

pymetkit-1.13.1/python/pymetkit/src/pymetkit/_version.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+from .pymetkit import *
+import importlib.metadata
+
+__version__ = importlib.metadata.version("pymetkit")

pymetkit-1.13.1/python/pymetkit/src/pymetkit/metkit_c.h

@@ -0,0 +1,52 @@
+
+struct metkit_marsrequest_t;
+typedef struct metkit_marsrequest_t metkit_marsrequest_t;
+struct metkit_requestiterator_t;
+typedef struct metkit_requestiterator_t metkit_requestiterator_t;
+struct metkit_paramiterator_t;
+typedef struct metkit_paramiterator_t metkit_paramiterator_t;
+
+typedef enum metkit_error_values_t {
+    METKIT_SUCCESS       = 0, /* Operation succeded. */
+    METKIT_ERROR         = 1, /* Operation failed. */
+    METKIT_ERROR_UNKNOWN = 2, /* Failed with an unknown error. */
+    METKIT_ERROR_USER    = 3, /* Failed with an user error. */
+    METKIT_ERROR_ASSERT  = 4  /* Failed with an assert() */
+} metkit_error_t;
+
+typedef enum metkit_iterator_status_t {
+    METKIT_ITERATOR_SUCCESS  = 0, /* Operation succeded. */
+    METKIT_ITERATOR_COMPLETE = 1, /* All elements have been returned */
+    METKIT_ITERATOR_ERROR    = 2  /* Operation failed. */
+} metkit_iterator_status_t;
+
+
+const char* metkit_get_error_string(enum metkit_error_values_t err);
+const char* metkit_version();
+const char* metkit_git_sha1();
+metkit_error_t metkit_initialise();
+
+metkit_error_t metkit_parse_marsrequests(const char* str, metkit_requestiterator_t** requests, bool strict);
+metkit_error_t metkit_marsrequest_new(metkit_marsrequest_t** request);
+metkit_error_t metkit_marsrequest_delete(const metkit_marsrequest_t* request);
+metkit_error_t metkit_marsrequest_set(metkit_marsrequest_t* request, const char* param, const char* values[],
+                                      int numValues);
+metkit_error_t metkit_marsrequest_set_one(metkit_marsrequest_t* request, const char* param, const char* value);
+metkit_error_t metkit_marsrequest_set_verb(metkit_marsrequest_t* request, const char* verb);
+metkit_error_t metkit_marsrequest_verb(const metkit_marsrequest_t* request, const char** verb);
+metkit_error_t metkit_marsrequest_has_param(const metkit_marsrequest_t* request, const char* param, bool* has);
+metkit_error_t metkit_marsrequest_params(const metkit_marsrequest_t* request, metkit_paramiterator_t** params);
+metkit_error_t metkit_marsrequest_count_values(const metkit_marsrequest_t* request, const char* param, size_t* count);
+metkit_error_t metkit_marsrequest_value(const metkit_marsrequest_t* request, const char* param, int index,
+                                        const char** value);
+metkit_error_t metkit_marsrequest_expand(const metkit_marsrequest_t* request, bool inherit, bool strict,
+                                         metkit_marsrequest_t* expandedRequest);
+metkit_error_t metkit_marsrequest_merge(metkit_marsrequest_t* request, const metkit_marsrequest_t* otherRequest);
+
+metkit_error_t metkit_requestiterator_delete(const metkit_requestiterator_t* it);
+metkit_iterator_status_t metkit_requestiterator_next(metkit_requestiterator_t* it);
+metkit_iterator_status_t metkit_requestiterator_current(metkit_requestiterator_t* it, metkit_marsrequest_t* request);
+
+metkit_error_t metkit_paramiterator_delete(const metkit_paramiterator_t* it);
+metkit_iterator_status_t metkit_paramiterator_next(metkit_paramiterator_t* it);
+metkit_iterator_status_t metkit_paramiterator_current(const metkit_paramiterator_t* it, const char** param);

pymetkit-1.13.1/python/pymetkit/src/pymetkit/pymetkit.py

@@ -0,0 +1,312 @@
+import os
+from cffi import FFI
+import findlibs
+from typing import IO, Iterator
+import warnings
+from ._version import __version__
+
+ffi = FFI()
+
+
+def ffi_encode(data) -> bytes:
+    if isinstance(data, bytes):
+        return data
+
+    if not isinstance(data, str):
+        data = str(data)
+
+    return data.encode(encoding="utf-8", errors="surrogateescape")
+
+
+def ffi_decode(data: FFI.CData) -> str:
+    buf = ffi.string(data)
+    if isinstance(buf, str):
+        return buf
+    else:
+        return buf.decode(encoding="utf-8", errors="surrogateescape")
+
+
+class MarsRequest:
+    def __init__(self, verb: str | None = None, **kwargs):
+        """
+        Create MetKit MarsRequest object. Parameters and values in
+        the request can be specified through kwargs, noting that
+        reserved words in Python must be suffixed with "_" e.g. "class_"
+        """
+        crequest = ffi.new("metkit_marsrequest_t **")
+        lib.metkit_marsrequest_new(crequest)
+        self.__request = ffi.gc(crequest[0], lib.metkit_marsrequest_delete)
+        if verb is not None:
+            lib.metkit_marsrequest_set_verb(self.__request, ffi_encode(verb))
+        for param, values in kwargs.items():
+            self[param.rstrip("_")] = values
+
+    def ctype(self) -> FFI.CData:
+        return self.__request
+
+    def verb(self) -> str:
+        cverb = ffi.new("const char **")
+        lib.metkit_marsrequest_verb(self.__request, cverb)
+        return ffi_decode(cverb[0])
+
+    def expand(self, inherit: bool = True, strict: bool = False) -> "MarsRequest":
+        """
+        Return expanded request
+
+        Params
+        ------
+        inherit: bool, if True, populates expanded request with default values
+        strict: bool, if True, raise error instead of warning for invalid values
+
+        Returns
+        -------
+        Request, resulting from expansion
+        """
+        expanded_request = MarsRequest()
+        lib.metkit_marsrequest_expand(
+            self.__request, inherit, strict, expanded_request.ctype()
+        )
+        return expanded_request
+
+    def validate(self):
+        """
+        Check if request is valid against MARS language definition. Does not
+        inherit missing parameters.
+
+        Raises
+        ------
+        Exception if request is incompatible with MARS language definition
+        """
+        self.expand(False, True)
+
+    def keys(self) -> Iterator[str]:
+        """
+        Get iterator over parameters in request
+
+        Returns
+        -------
+        Iterator over parameter names
+        """
+        it_c = ffi.new("metkit_paramiterator_t **")
+        lib.metkit_marsrequest_params(self.__request, it_c)
+        it = ffi.gc(it_c[0], lib.metkit_paramiterator_delete)
+        
+        while lib.metkit_paramiterator_next(it) == lib.METKIT_ITERATOR_SUCCESS:
+            cparam = ffi.new("const char **")
+            lib.metkit_paramiterator_current(it, cparam)
+            param = ffi_decode(cparam[0])
+            yield param
+
+    def num_values(self, param: str) -> int:
+        """
+        Number of values for parameter
+
+        Params
+        ------
+        param: parameter name
+
+        Returns
+        -------
+        int
+        """
+        cparam = ffi_encode(param)
+        count = ffi.new("size_t *", 0)
+        lib.metkit_marsrequest_count_values(self.__request, cparam, count)
+        return count[0]
+
+    def merge(self, other: "MarsRequest") -> "MarsRequest":
+        """
+        Merge the values in another request with existing request and returns result as a
+        new Request object. Does not modify inputs to merge. Both input requests must contain
+        the same values and the resulting request object must be compatible with MARS language
+        definition
+
+        Params
+        ------
+        other: Request, request to merge with self
+
+        Returns
+        -------
+        Request, containing the result of the merge
+
+        Raises
+        ------
+        ValueError if parameters in the two requests do not match
+        MetKitException if resulting request is not compatible with MARS language definition
+        """
+        if set(self.keys()) != set(other.keys()):
+            raise ValueError("Can not merge requests with different parameters.")
+        res = MarsRequest(self.verb(), **{k: v for k, v in self})
+        lib.metkit_marsrequest_merge(res.ctype(), other.ctype())
+        res.validate()
+        return res
+
+    def __iter__(self) -> Iterator[tuple[str, list[str]]]:
+        for param in self.keys():
+            yield param, self[param]
+
+    def __getitem__(self, param: str) -> str | list[str]:
+        nvalues = self.num_values(param)
+        values = []
+        for index in range(nvalues):
+            cvalue = ffi.new("const char **")
+            lib.metkit_marsrequest_value(self.__request, ffi_encode(param), index, cvalue)
+            value = ffi_decode(cvalue[0])
+            if nvalues == 1:
+                return value
+            values.append(value)
+        return values
+
+    def __contains__(self, param: str) -> bool:
+        has = ffi.new("bool *", False)
+        lib.metkit_marsrequest_has_param(self.__request, ffi_encode(param), has)
+        return has[0]
+
+    def __setitem__(self, param: str, values: int | str | list[str]):
+        if isinstance(values, (str, int)):
+            values = [values]
+        cvals = []
+        for value in values:
+            if isinstance(value, int):
+                value = str(value)
+            cvals.append(ffi.new("const char[]", value.encode("ascii")))
+        lib.metkit_marsrequest_set(
+            self.__request,
+            ffi_encode(param),
+            ffi.new("const char*[]", cvals),
+            len(values),
+        )
+
+    def __eq__(self, other: "MarsRequest") -> bool:
+        if self.verb() != other.verb():
+            return False
+        expanded = self.expand()
+        other_expanded = other.expand()
+        return dict(expanded) == dict(other_expanded)
+
+
+def parse_mars_request(file_or_str: IO | str, strict: bool = False) -> list[MarsRequest]:
+    """
+    Function for parsing mars request from file object or string.
+
+    Params
+    ------
+    file_or_str: string or file-like object, containing mars request
+    strict: bool, whether to raise error or warning when request is not compatible with
+    MARS language definition. In the case of warning, when False, the incompatible
+    parameters are unset from the request.
+
+    Returns
+    -------
+    list of Request
+    """
+    crequest_iter = ffi.new("metkit_requestiterator_t **")
+
+    if isinstance(file_or_str, str):
+        lib.metkit_parse_marsrequests(ffi_encode(file_or_str), crequest_iter, strict)
+    else:
+        lib.metkit_parse_marsrequests(
+            ffi_encode(file_or_str.read()), crequest_iter, strict
+        )
+    request_iter = ffi.gc(crequest_iter[0], lib.metkit_requestiterator_delete)
+
+    requests = []
+    while lib.metkit_requestiterator_next(request_iter) == lib.METKIT_ITERATOR_SUCCESS:
+        new_request = MarsRequest()
+        lib.metkit_requestiterator_current(request_iter, new_request.ctype())
+        requests.append(new_request)
+
+    return requests
+
+
+class MetKitException(RuntimeError):
+    """Raised when MetKit library throws exception"""
+
+    pass
+
+
+class CFFIModuleLoadFailed(ImportError):
+    """Raised when the shared library fails to load"""
+
+    pass
+
+
+class PatchedLib:
+    """
+    Patch a CFFI library with error handling
+
+    Finds the header file associated with the MetKit C API and parses it,
+    loads the shared library, and patches the accessors with
+    automatic python-C error handling.
+    """
+
+    def __init__(self):
+        libName = findlibs.find("metkit")
+
+        if libName is None:
+            raise RuntimeError("MetKit library not found")
+
+        ffi.cdef(self.__read_header())
+        self.__lib = ffi.dlopen(libName)
+
+        # All of the executable members of the CFFI-loaded library are functions in the MetKit
+        # C API. These should be wrapped with the correct error handling. Otherwise forward
+        # these on directly.
+
+        for f in dir(self.__lib):
+            try:
+                attr = getattr(self.__lib, f)
+                setattr(
+                    self, f, self.__check_error(attr, f) if callable(attr) else attr
+                )
+            except Exception as e:
+                print(e)
+                print("Error retrieving attribute", f, "from library")
+
+        # Initialise the library, and set it up for python-appropriate behaviour
+
+        self.metkit_initialise()
+
+        # Check the library version
+
+        versionstr = ffi.string(self.metkit_version()).decode("utf-8")
+        if versionstr != __version__:
+            warnings.warn(f"Metkit library version {versionstr} does not match python version {__version__}")
+
+    def __read_header(self):
+        with open(os.path.join(os.path.dirname(__file__), "metkit_c.h"), "r") as f:
+            return f.read()
+
+    def __check_error(self, fn, name: str):
+        """
+        If calls into the MetKit library return errors, ensure that they get
+        detected and reported by throwing an appropriate python exception.
+        """
+
+        def wrapped_fn(*args, **kwargs):
+
+            # debug
+            retval = fn(*args, **kwargs)
+
+            # Some functions dont return error codes. Ignore these.
+            if name in ["metkit_version", "metkit_git_sha1"]:
+                return retval
+
+            # error codes:
+            if retval not in (
+                self.__lib.METKIT_SUCCESS,
+                self.__lib.METKIT_ITERATOR_SUCCESS,
+                self.__lib.METKIT_ITERATOR_COMPLETE,
+            ):
+                err = ffi_decode(self.__lib.metkit_get_error_string(retval))
+                msg = "Error in function '{}': {}".format(name, err)
+                raise MetKitException(msg)
+            return retval
+
+        return wrapped_fn
+
+
+try:
+    lib = PatchedLib()
+except CFFIModuleLoadFailed as e:
+    raise ImportError() from e

pymetkit-1.13.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+