nnpdf-data 0.0.2__py3-none-any.whl → 4.0.10__py3-none-any.whl

nnpdf_data/commondata/ZEUS_2JET_319GEV_374PB-1_DIF/metadata.yaml

@@ -17,40 +17,39 @@ version_comment: "Separated luminosity uncertainty"
 
 implemented_observables:
 
-  - observable: {description: "double differential cross section w.r.t. E_T and q^2", label: '$\frac{d^2\sigma}{dE_Tdq^2}$', units: "$pb/GeV^3$"}
-    observable_name: ETQ2
-    process_type: HERADIJET
-    ndata: 22
-    tables: [13, 14, 15, 16, 17, 18]
-    kinematics:
-      variables:
-        ET: {description: "mean jet transverse energy of the dijet system in the Breit frame", label: '$\langle E_{T, B} \rangle$', units: "$GeV$"}
-        Q2: {description: "momentum transferred squared", label: "$q^2$", units: "$GeV^2$"}
-        sqrts: {description: "center of mass energy", label: '$\sqrt{s}$', units: "$GeV$"}
-      file: kinematics_q2_et.yaml
-    data_central: data_q2_et.yaml
-    data_uncertainties:
+- observable: {description: "double differential cross section w.r.t. E_T and q^2", label: '$\frac{d^2\sigma}{dE_Tdq^2}$', units: "$pb/GeV^3$"}
+  observable_name: ETQ2
+  process_type: HERADIJET
+  ndata: 22
+  tables: [13, 14, 15, 16, 17, 18]
+  kinematics:
+    variables:
+      ET: {description: "mean jet transverse energy of the dijet system in the Breit frame", label: '$\langle E_{T, B} \rangle$', units: "$GeV$"}
+      Q2: {description: "momentum transferred squared", label: "$q^2$", units: "$GeV^2$"}
+      sqrts: {description: "center of mass energy", label: '$\sqrt{s}$', units: "$GeV$"}
+    file: kinematics_q2_et.yaml
+  data_central: data_q2_et.yaml
+  data_uncertainties:
+  - uncertainties_q2_et_wo-lumi.yaml
+  - uncertainties_q2_et_lumi.yaml
+  kinematic_coverage: [ET, Q2, sqrts]
+  plotting:
+    dataset_label: '$ZEUS\ DiJet\ 374\ pb^{-1}:\ \frac{d^2\sigma}{dE_Tdq^2}$'
+    plot_x: ET
+    y_label: '$\frac{d^2\sigma}{dE_Tdq^2}$ ($pb/GeV^3$)'
+    x_scale: log
+    figure_by:
+    - Q2
+  theory:
+    FK_tables:
+    - - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN1
+      - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN2
+      - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN3
+      - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN4
+      - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN5
+      - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN6
+    operation: 'null'
+  variants:
+    wo-lumi:
+      data_uncertainties:
       - uncertainties_q2_et_wo-lumi.yaml
-      - uncertainties_q2_et_lumi.yaml
-    kinematic_coverage: [ET, Q2, sqrts]
-    plotting:
-      kinematics_override: identity
-      dataset_label: '$ZEUS\ DiJet\ 374\ pb^{-1}:\ \frac{d^2\sigma}{dE_Tdq^2}$'
-      plot_x: ET
-      y_label: '$\frac{d^2\sigma}{dE_Tdq^2}$ ($pb/GeV^3$)'
-      x_scale: log
-      figure_by:
-        - Q2
-    theory:
-      FK_tables:
-        - - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN1
-          - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN2
-          - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN3
-          - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN4
-          - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN5
-          - ZEUS_2JET_319GEV_374PB-1_DIF_ETQ2_BIN6
-      operation: 'null'
-    variants:
-      wo-lumi:
-        data_uncertainties:
-          - uncertainties_q2_et_wo-lumi.yaml

nnpdf_data/commondata/dataset_names.yml

@@ -330,7 +330,7 @@ CMS_SINGLETOP_TCH_TOT_7TEV:
   dataset: CMS_SINGLETOP_7TEV_TCHANNEL-XSEC
   variant: legacy
 CMS_TTB_DIFF_13TEV_2016_LJ_TRAP:
-  dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YTTBAR
+  dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT
   variant: legacy
 POSDYS:
   dataset: NNPDF_POS_2P24GEV_DYS
@@ -412,3 +412,6 @@ ATLAS_WJ_JET_8TEV_WM-PT:
 ATLAS_WJ_JET_8TEV_WP-PT:
   dataset: ATLAS_WJ_8TEV_WP-PT
   variant: legacy
+CMS_TTBAR_13TEV_LJ_2016_DIF_YTTBAR:
+  dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT
+  variant: legacy

nnpdf_data/commondataparser.py

@@ -50,7 +50,7 @@ from validobj.custom import Parser
 from .coredata import KIN_NAMES, CommonData
 from .process_options import ValidProcess
 from .utils import parse_yaml_inp, quick_yaml_load
-from .validphys_compatibility import new_to_legacy_map, path_commondata
+from .validphys_compatibility import legacy_to_new_map, new_to_legacy_map, path_commondata
 
 try:
     from validphys.plotoptions.plottingoptions import PlottingOptions, labeler_functions
@@ -64,7 +64,6 @@ except ModuleNotFoundError:
 
     VP_AVAILABLE = False
 
-
 # JCM:
 # Some notes for developers
 # The usage of `frozen` in the definitions of the dataclass is not strictly necessary
@@ -470,8 +469,16 @@ class ObservableMetaData:
     def apply_variant(self, variant_name):
         """Return a new instance of this class with the variant applied
 
-        This class also defines how the variant is applied to the commondata
+        This class also defines how the variant is applied to the commondata.
+        If more than a variant is being used, this function will be called recursively
+        until all variants are applied.
         """
+        if not isinstance(variant_name, str):
+            observable = self
+            for single_variant in variant_name:
+                observable = observable.apply_variant(single_variant)
+            return observable
+
         try:
             variant = self.variants[variant_name]
         except KeyError as e:
@@ -487,7 +494,6 @@ class ObservableMetaData:
 
         # This section should only be used for the purposes of reproducibility
         # of legacy data, no new data should use these
-
         if variant.experiment is not None:
             new_nnpdf_metadata = dict(self._parent.nnpdf_metadata.items())
             new_nnpdf_metadata["experiment"] = variant.experiment
@@ -495,7 +501,13 @@ class ObservableMetaData:
             variant_replacement["_parent"] = setmetadata_copy
             variant_replacement["plotting"] = dataclasses.replace(self.plotting)
 
-        return dataclasses.replace(self, applied_variant=variant_name, **variant_replacement)
+        # Keep track of applied variants:
+        if self.applied_variant is None:
+            varname = variant_name
+        else:
+            varname = f"{self.applied_variant}_{variant_name}"
+
+        return dataclasses.replace(self, applied_variant=varname, **variant_replacement)
 
     @property
     def is_positivity(self):
@@ -827,9 +839,23 @@ class SetMetaData:
         try:
             observable = self.allowed_observables[obs_name]
         except KeyError:
-            raise ValueError(
-                f"The selected observable {obs_name_raw} does not exist in {self.setname}"
-            )
+            std_err = f"The selected observable {obs_name_raw} does not exist in {self.setname}"
+            # If the error is due to the usage of an old name, give some extra information
+            name = f"{self.setname}_{obs_name_raw}"
+            new_name, map_variant = legacy_to_new_map(name, None)
+            if new_name == name:
+                # It was just a mistake, raise the original error
+                raise ValueError(std_err)
+            if map_variant is None:
+                dinput_str = f"- {{ dataset: {new_name} }}"
+            else:
+                dinput_str = f"- {{ dataset: {new_name}, variant: {map_variant} }}"
+            std_err += f"""
+It might be that you used an older name for the dataset: '{name}'.
+If this is a mistake, please use '{new_name}' instead. E.g.,
+    {dinput_str}
+"""
+            raise ValueError(std_err)
 
         # Now burn the _parent key into the observable and apply checks
         object.__setattr__(observable, "_parent", self)
@@ -855,7 +881,7 @@ def parse_new_metadata(metadata_file, observable_name, variant=None):
     # Select one observable from the entire metadata
     metadata = set_metadata.select_observable(observable_name)
 
-    # And apply variant if given
+    # And apply variant or variants if given
     if variant is not None:
         metadata = metadata.apply_variant(variant)
 

nnpdf_data/coredata.py

@@ -1,5 +1,5 @@
 """
-    The all-important CommonData object
+The all-important CommonData object
 """
 
 import dataclasses
@@ -8,7 +8,7 @@ from typing import Optional
 import numpy as np
 import pandas as pd
 
-from .utils import yaml
+from .utils import yaml_safe
 
 KIN_NAMES = ["kin1", "kin2", "kin3"]
 
@@ -199,7 +199,7 @@ class CommonData:
     def export_data(self, buffer):
         """Exports the central data defined by this commondata instance to the given buffer"""
         ret = {"data_central": self.central_values.tolist()}
-        yaml.safe_dump(ret, buffer)
+        yaml_safe.dump(ret, buffer)
 
     def export_uncertainties(self, buffer):
         """Exports the uncertainties defined by this commondata instance to the given buffer"""
@@ -214,6 +214,7 @@ class CommonData:
             k: v for k, v in sorted(definitions.items(), key=lambda item: item[1]["treatment"])
         }
         bins = []
+
         for idx, row in self.systematic_errors().iterrows():
             tmp = {"stat": float(self.stat_errors[idx])}
             # Hope things come in the right order...
@@ -228,7 +229,7 @@ class CommonData:
             "type": "UNCORR",
         }
         ret = {"definitions": sorted_definitions, "bins": bins}
-        yaml.safe_dump(ret, buffer)
+        yaml_safe.dump(ret, buffer)
 
     def export(self, folder_path):
         """Wrapper around export_data and export_uncertainties
@@ -241,6 +242,8 @@ class CommonData:
         data_path = folder_path / data_path.name
         unc_path = folder_path / unc_path.name
         # Export data and uncertainties
-        self.export_data(data_path.open("w", encoding="utf-8"))
-        self.export_uncertainties(unc_path.open("w", encoding="utf-8"))
+        with open(data_path, "w", encoding="utf-8") as file:
+            self.export_data(file)
+        with open(unc_path, "w", encoding="utf-8") as file:
+            self.export_uncertainties(file)
         return data_path, unc_path

nnpdf_data/filter_utils/hera_utils.py

@@ -1,105 +1,73 @@
-from pathlib import Path
 from dataclasses import dataclass
-import typing
+from pathlib import Path
 from typing import List
+
 import numpy as np
-import pandas as pd
-from os import PathLike
 import yaml
-#from validphys.api import API
 
-@dataclass 
+
+@dataclass
 class commondata:
-   central_values: np.ndarray
-   kinematics: np.ndarray
-   statistical_uncertainties: np.ndarray
-   systematic_uncertainties: np.ndarray
-   systypes: List[tuple[str, str]]
-   process: str
-   dataset_name: str
-   kinematic_quantities: List[str]
+    central_values: np.ndarray
+    kinematics: np.ndarray
+    statistical_uncertainties: np.ndarray
+    systematic_uncertainties: np.ndarray
+    systypes: List[tuple[str, str]]
+    process: str
+    dataset_name: str
+    kinematic_quantities: List[str]
 
-  
-   # Procedure to create data_*.yaml, kinematics_*.yaml and uncertainties_*.yaml
-   def write_new_commondata(self, data_filename: str | PathLike,
-                            kinematics_filename: str | PathLike,
-                            uncertainties_filename: str | PathLike): 
-      # central data values
-      data = {"data_central": self.central_values.tolist()}
-      with data_filename.open("w+") as f:
-         yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+    # Procedure to create data_*.yaml, kinematics_*.yaml and uncertainties_*.yaml
+    def write_new_commondata(
+        self, data_filename: Path, kinematics_filename: Path, uncertainties_filename: Path
+    ):
+        # central data values
+        data = {"data_central": self.central_values.tolist()}
+        with data_filename.open("w+") as f:
+            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
 
-      # kinematic quantieties
-      # TODO add arrays for min and max values to derived type?
-      bins = []
-      for kin in self.kinematics.tolist():
-         bins.append(
-            {self.kinematic_quantities[0]: 
-               {
-               "min": None,
-               "mid": kin[0],
-               "max": None
-               },
-            self.kinematic_quantities[1]:
-               {
-               "min": None,
-               "mid": kin[1],
-               "max": None
-               },
-            self.kinematic_quantities[2]:
-               {
-               "min": None,
-               "mid": kin[2],
-               "max": None
-               }
-             })
-      data = {"bins": bins}
-      with kinematics_filename.open("w+") as f:
-         yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+        # kinematic quantieties
+        # TODO add arrays for min and max values to derived type?
+        bins = []
+        for kin in self.kinematics.tolist():
+            bins.append(
+                {
+                    self.kinematic_quantities[0]: {"min": None, "mid": kin[0], "max": None},
+                    self.kinematic_quantities[1]: {"min": None, "mid": kin[1], "max": None},
+                    self.kinematic_quantities[2]: {"min": None, "mid": kin[2], "max": None},
+                }
+            )
+        data = {"bins": bins}
+        with kinematics_filename.open("w+") as f:
+            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
 
-      # uncertainties
-      # There is only one statistical uncertainty per datapoint.
-      definitions = {"stat": 
-                       {
-                          "description": "Statistical uncertainty.", 
-                          "treatment": "ADD", 
-                          "type": "UNCORR"
-                       }
+        # uncertainties
+        # There is only one statistical uncertainty per datapoint.
+        definitions = {
+            "stat": {
+                "description": "Statistical uncertainty.",
+                "treatment": "ADD",
+                "type": "UNCORR",
+            }
+        }
+        for isys, sys in enumerate(self.systypes):
+            definitions.update(
+                {
+                    f"sys_corr_{isys}": {
+                        "description": f"Systematic uncertainty {isys}",
+                        "treatment": sys[0],
+                        "type": sys[1],
                     }
-      for isys, sys in enumerate(self.systypes):
-         definitions.update(
-            {f"sys_corr_{isys}":
-               {
-                  "description": f"Systematic uncertainty {isys}",
-                  "treatment": sys[0],
-                  "type": sys[1]
-               }
-            })
-      bins = {"bins": [] }
-      for i, _ in enumerate(self.central_values):
-         systematics = {"stat": self.statistical_uncertainties.tolist()[i]}
-         for isys, sys in enumerate(self.systematic_uncertainties[i].tolist()):
-            systematics.update({f"sys_corr_{isys}": sys})
-         bins["bins"].append(systematics)
-      data = {"definitions": definitions }
-      # TODO Notation of reals is inconsistent from yaml.safe_dump
-      #      sometimes it is in scientific notation sometimes not...
-      with uncertainties_filename.open("w+") as f:
-         yaml.safe_dump(data, f, default_flow_style=False, sort_keys=False)
-         yaml.safe_dump(bins, f, default_flow_style=False, sort_keys=False)
-      
-
-# Subroutines for testing the implementation of the commondata.
-
-## Obtain the covariance matrix for a given variant.
-#def _covmat(name: str, var: str):
-#   inp = {"dataset_input": {"dataset": name, "variant": var}, "theoryid": 700, "use_cuts": "internal"}
-#   return API.covmat_from_systematics(**inp)
-#
-## Compare the covariance matrices of two different variants. True if close.
-#def covmat_is_close(name: str, var1: str, var2: str) -> bool:
-#   return np.isclose(_covmat(name,var1),_covmat(name,var2)).all()
-
-
-
+                }
+            )
+        bins = {"bins": []}
+        for i, _ in enumerate(self.central_values):
+            systematics = {"stat": self.statistical_uncertainties.tolist()[i]}
+            for isys, sys in enumerate(self.systematic_uncertainties[i].tolist()):
+                systematics.update({f"sys_corr_{isys}": sys})
+            bins["bins"].append(systematics)
+        data = {"definitions": definitions}
 
+        with uncertainties_filename.open("w+") as f:
+            yaml.dump(data, f, sort_keys=False)
+            yaml.dump(bins, f, sort_keys=False)

nnpdf_data/process_options.py

@@ -1,7 +1,7 @@
 """
-    Module to hold process dependent options
+Module to hold process dependent options
 
-    Only variables included in the `_Vars` enum and processes included in the ``Processes`` dictionary are allowed.
+Only variables included in the `_Vars` enum and processes included in the ``Processes`` dictionary are allowed.
 """
 
 import dataclasses
@@ -16,6 +16,7 @@ class _Vars:
     Q2 = "Q2"
     Q = "Q"
     y = "y"
+    abs_y = "abs_y"
     pT = "pT"
     ET = "ET"
     sqrts = "sqrts"
@@ -26,6 +27,7 @@ class _Vars:
     y_t = "y_t"
     y_ttBar = "y_ttBar"
     m_t2 = "m_t2"
+    m_t = "m_t"
     pT_t = "pT_t"
     m_ttBar = "m_ttBar"
     eta = "eta"
@@ -33,6 +35,9 @@ class _Vars:
     m_W2 = "m_W2"
     m_Z2 = "m_Z2"
     m_V2 = "m_V2"
+    m_W = "m_W"
+    m_Z = "m_Z"
+    M2 = "M2"
     abs_eta_1 = "abs_eta_1"
     abs_eta_2 = "abs_eta_2"
     eta_1 = "eta_1"
@@ -94,7 +99,9 @@ class _Process:
             return True
         # We check if kin_cov is a subset of self.accepted_variables
         kin_cov = [v for v in kin_cov if not v.startswith("extra_")]
-        return set(self.accepted_variables).union(set(kin_cov)) == set(self.accepted_variables)
+        # sqrts is always accepted
+        accepted = set(self.accepted_variables).union({_Vars.sqrts})
+        return accepted.union(set(kin_cov)) == accepted
 
     def xq2map(self, kin_df, metadata):
         """Transform the kinematics dataframe into a x q dataframe
@@ -137,6 +144,9 @@ def _dis_xq2map(kin_info):
     x = kin_info.get_one_of("k1", _Vars.x)
     if "k2" in kin_info._kins:
         q2 = kin_info.get_one_of("k2") ** 2
+    elif _Vars.Q in kin_info._kins:
+        q = kin_info.get_one_of(_Vars.Q)
+        q2 = q**2
     else:
         q2 = kin_info.get_one_of(_Vars.Q2)
     return x, q2
@@ -227,8 +237,11 @@ def _hqp_mqq_xq2map(kin_info):
 
 def _inc_xq2map(kin_info):
     # Compute x, Q2
-    # k2 necessary to take the mass for DY inclusive cross sections still not migrated
-    mass2 = kin_info.get_one_of(_Vars.m_W2, _Vars.m_Z2, _Vars.m_t2, "k2")
+    try:
+        mass = kin_info.get_one_of(_Vars.m_W, _Vars.m_Z, _Vars.m_t, _Vars.m_ll)
+        mass2 = mass**2
+    except KeyError:
+        mass2 = kin_info.get_one_of(_Vars.m_W2, _Vars.m_Z2, _Vars.m_t2, _Vars.m_ll)
     return np.sqrt(mass2) / kin_info[_Vars.sqrts], mass2
 
 
@@ -250,8 +263,8 @@ def _dyboson_xq2map(kin_info):
     Computes x and q2 mapping for pseudo rapidity observables
     originating from a W boson DY process.
     """
-    mass2 = kin_info.get_one_of(_Vars.m_W2, _Vars.m_Z2, _Vars.m_V2)
-    eta = kin_info.get_one_of(_Vars.eta, _Vars.y, _Vars.abs_eta)
+    mass2 = kin_info.get_one_of(_Vars.m_W2, _Vars.m_Z2, _Vars.m_V2, _Vars.m_ll2, _Vars.M2)
+    eta = kin_info.get_one_of(_Vars.eta, _Vars.y, _Vars.abs_eta, _Vars.abs_y)
     sqrts = kin_info[_Vars.sqrts]
 
     # eta = y for massless particles
@@ -405,7 +418,7 @@ HQP_MQQ = _Process(
 INC = _Process(
     "INC",
     "Inclusive cross section",
-    accepted_variables=("zero", _Vars.sqrts, _Vars.m_W2, _Vars.m_Z2, _Vars.m_t2),
+    accepted_variables=("zero", _Vars.sqrts, _Vars.m_W2, _Vars.m_Z2, _Vars.m_t2, _Vars.m_ll),
     xq2map_function=_inc_xq2map,
 )
 
@@ -422,12 +435,17 @@ DY_2L = _Process(
     "DY W or Z -> 2 leptons ",
     accepted_variables=(
         _Vars.y,
+        _Vars.abs_y,
         _Vars.eta,
         _Vars.m_W2,
         _Vars.m_Z2,
         _Vars.m_V2,
+        _Vars.m_ll,
+        _Vars.m_ll2,
         _Vars.sqrts,
         _Vars.abs_eta,
+        _Vars.m_ll2,
+        _Vars.M2,
     ),
     xq2map_function=_dyboson_xq2map,
 )
@@ -469,6 +487,12 @@ POS_DIS = _Process(
     "POS_DIS", "Positivity of F2 structure functions", accepted_variables=(_Vars.x, _Vars.Q2)
 )
 
+POS_POL = _Process(
+    "POS_POL",
+    "Polarized DIS positivity boundary condition",
+    accepted_variables=(_Vars.x, _Vars.Q2, _Vars.y),
+)
+
 PHT = _Process(
     "PHT",
     "Photon production",
@@ -505,6 +529,7 @@ PROCESSES = {
     "JET_POL": JET_POL,
     "DIJET_POL": DIJET_POL,
     "DY_Z_Y": dataclasses.replace(DY_2L, name="DY_Z_Y", description="DY Z -> ll (pseudo)rapidity"),
+    "DYP_FT": dataclasses.replace(DY_2L, name="DYP_FT", description="DY Z -> ll (pseudo)rapidity"),
     "DY_MLL": DY_MLL,
     "DY_W_ETA": dataclasses.replace(
         DY_2L, name="DY_W_ETA", description="DY W -> l nu pseudorapidity"
@@ -517,6 +542,9 @@ PROCESSES = {
     "DY_NC_PTRAP": dataclasses.replace(DY_PT_RAP, name="DY_NC_PTRAP", description="DY Z (ll) + j"),
     "POS_XPDF": POS_XPDF,
     "POS_DIS": POS_DIS,
+    "POS_POL": POS_POL,
+    "POS_DY": dataclasses.replace(POS_DIS, name="POS_DY"),
+    "INTEG": dataclasses.replace(POS_DIS, name="INTEG", description="Integrability dataset"),
     "PHT": PHT,
     "SINGLETOP": SINGLETOP,
 }

nnpdf_data/theory_cards/41001000.yaml

@@ -0,0 +1,41 @@
+ID: 41_001_000
+Comments: FKtables generated with grids from 41_000_000 and ekos with 40_000_000 settings
+PTO: 2
+FNS: FONLL-C
+DAMP: 0
+IC: 1
+Q0: 1.65
+ModEv: TRN
+XIR: 1.0
+XIF: 1.0
+NfFF: 5
+QED: 0
+HQ: POLE
+mc: 1.51
+Qmc: 1.51
+kcThr: 1.0
+mb: 4.92
+Qmb: 4.92
+kbThr: 1.0
+mt: 172.5
+Qmt: 172.5
+ktThr: 1.0
+CKM:
+- 0.97428
+- 0.2253
+- 0.00347
+- 0.2252
+- 0.97345
+- 0.041
+- 0.00862
+- 0.0403
+- 0.999152
+MZ: 91.1876
+MW: 80.398
+GF: 1.1663787e-05
+SIN2TW: 0.23126
+TMC: 1
+MP: 0.938
+Qref: 91.2
+alphas: 0.118
+alphaqed: 0.0077553

nnpdf_data/utils.py

@@ -2,15 +2,9 @@ import pathlib
 
 from ruamel.yaml import YAML
 from validobj import ValidationError, parse_input
-import yaml
 
-yaml_rt = YAML(typ="rt")
-try:
-    # If libyaml is available, use the C loader
-    Loader = yaml.CLoader
-except AttributeError:
-    # fallback to the slow loader
-    Loader = yaml.Loader
+yaml_fast = YAML(typ='safe', pure=False)
+yaml_safe = YAML(typ='safe')
 
 
 def quick_yaml_load(filepath):
@@ -18,7 +12,7 @@ def quick_yaml_load(filepath):
     https://pyyaml.org/wiki/LibYAML
     libyaml is available for most linux distributions
     """
-    return yaml.load(filepath.read_text(encoding="utf-8"), Loader=Loader)
+    return yaml_fast.load(filepath.read_text(encoding="utf-8"))
 
 
 def parse_yaml_inp(input_yaml, spec):
@@ -36,12 +30,12 @@ def parse_yaml_inp(input_yaml, spec):
         current_exc = e
         # In order to provide a more complete error information, use round trip
         # to read the .yaml file again (insetad of using the CLoader)
-        current_inp = yaml_rt.load(input_yaml.open("r", encoding="utf-8"))
+        current_inp = YAML(typ="rt").load(input_yaml.open("r", encoding="utf-8"))
         error_text_lines = []
         while current_exc:
             if hasattr(current_exc, 'wrong_field'):
                 wrong_field = current_exc.wrong_field
-                # Mappings compping from yaml_rt have an
+                # Mappings coming from YAML(rt) have an
                 # ``lc`` attribute that gives a tuple of
                 # ``(line_number, column)`` for a given item in
                 # the mapping.