atlas-ftag-tools 0.1.13__py3-none-any.whl → 0.1.16__py3-none-any.whl

{atlas_ftag_tools-0.1.13.dist-info → atlas_ftag_tools-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atlas-ftag-tools
-Version: 0.1.13
+Version: 0.1.16
 Summary: ATLAS Flavour Tagging Tools
 Author: Sam Van Stroud, Philipp Gadow
 License: MIT
@@ -102,6 +102,19 @@ By default the working points are printed to the terminal, but you can save the
 
 See `wps --help` for more options and information.
 
+## Calculate efficiency at discriminant cut 
+
+The same script can be used to calculate the efficiency and rejection values at a given discriminant cut value.
+The script `working_points.py` can be run after intalling this package as follows
+
+```
+wps \
+    --ttbar "path/to/ttbar/*.h5" \
+    --tagger GN120220509 \
+    --fx 0.1
+    --disc_cuts 1.0 1.5
+```
+The `--tagger`, `--fx`, and `--outfile` follow the same procedure as in the 'Calculate WPs' script as described above.
 
 ## H5 Utils
 

atlas_ftag_tools-0.1.16.dist-info/RECORD

@@ -0,0 +1,23 @@
+ftag/__init__.py,sha256=PN9ZbZHVfxreetH3HnhEbZf1G-J4Up-5si-dQ4rrezg,629
+ftag/cuts.py,sha256=RYAfK3MkEhYhlKQFWQTKu72ZrUwlExFeT8IWLSIgeTU,2798
+ftag/flavour.py,sha256=BLifDbJCoszPzgrU5X3Txff9fTMuVGEjUeU0OtOfllc,2701
+ftag/flavours.yaml,sha256=9ifKyz1_VoHlOaWuf3JEqMLSYyLFedYJf9x1D6dCTnM,5335
+ftag/git_check.py,sha256=TvF502eqDrYzhI-SgruVolx1BPJi-J0mswc4pmgaYY8,1621
+ftag/mock.py,sha256=T2YGeuCkgDEzKPVYwU7Vnq5TNIDrx9eIDVrAQt8s0Mw,4865
+ftag/region.py,sha256=-WxdC0Gy9zz3zEJ2pN779RcxXPG-QEROuMwMoP-Qs0g,353
+ftag/sample.py,sha256=cd-rNHsEY2aWSZdy3V4bOKi3aDMtHTCpjXS8Hl9zwUY,2597
+ftag/transform.py,sha256=uEGGJSnqoKOzLYQv650XdK_kDNw4Aw-5dc60z9Dp_y0,3963
+ftag/vds.py,sha256=PG-NCJdpmK5X2l8i8YWBHx6CY8vosShfqp36facKaYM,3383
+ftag/hdf5/__init__.py,sha256=pZva2TI8nvpBwoawcm_ucVZbGsQJW_u8GGoJgt5mKEw,354
+ftag/hdf5/h5move.py,sha256=1XxiJZ96DYSp8JF0ry3lbRSQaFX72DjUV5vBA6hYw-0,873
+ftag/hdf5/h5reader.py,sha256=et-_LXt942xegqc14bPapUgIO7MUfC2m04uJslLkXxI,13579
+ftag/hdf5/h5split.py,sha256=BlhpsUlqBSDCjVRWuyEq1OImyzwp7VyVkDrCz7pvQKc,2508
+ftag/hdf5/h5utils.py,sha256=wjbAmFY5GoFkWW_AvEKTPbwYMFroHKKFuIcehd91dhM,3222
+ftag/hdf5/h5writer.py,sha256=5jm3vSk4m77lFSUyWm-i_y_USzQRVoKpLL8F_cii65Q,4826
+ftag/wps/discriminant.py,sha256=0YmI3-ieSWReO_uY4-3Sc_85hLVpoCHQ7LfuU1SC_Sg,2318
+ftag/wps/working_points.py,sha256=pLoe8RaVmbtiGM9TxMtWocMohBWrY6JcMCLE_e3XtVY,8033
+atlas_ftag_tools-0.1.16.dist-info/METADATA,sha256=H547FpfWZ6plg5PXm7E9SJhppKGWM8iKM_EpFJaUNJs,5064
+atlas_ftag_tools-0.1.16.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+atlas_ftag_tools-0.1.16.dist-info/entry_points.txt,sha256=LfVLsZHQolqbPnwPgtmc5IQTh527BKkN2v-IpXWTNHw,137
+atlas_ftag_tools-0.1.16.dist-info/top_level.txt,sha256=qiYQuKcAvMim-31FwkT3MTQu7WQm0s58tPAia5KKWqs,5
+atlas_ftag_tools-0.1.16.dist-info/RECORD,,

ftag/__init__.py

@@ -1,7 +1,7 @@
 """atlas-ftag-tools - Common tools for ATLAS flavour tagging software."""
 from __future__ import annotations
 
-__version__ = "v0.1.13"
+__version__ = "v0.1.16"
 
 
 from ftag import hdf5

ftag/flavour.py

@@ -80,9 +80,20 @@ class FlavourContainer:
                 return flavour
         raise KeyError(f"Flavour with {cuts} not found")
 
+    @classmethod
+    def from_yaml(cls, yaml_path: Path | None = None) -> FlavourContainer:
+        if yaml_path is None:
+            yaml_path = Path(__file__).parent / "flavours.yaml"
 
-with open(Path(__file__).parent / "flavours.yaml") as f:
-    flavours_yaml = yaml.safe_load(f)
-flavours_dict = {f["name"]: Flavour(cuts=Cuts.from_list(f.pop("cuts")), **f) for f in flavours_yaml}
-assert len(flavours_dict) == len(flavours_yaml), "Duplicate flavour names detected"
-Flavours = FlavourContainer(flavours_dict)
+        with open(yaml_path) as f:
+            flavours_yaml = yaml.safe_load(f)
+
+        flavours_dict = {
+            f["name"]: Flavour(cuts=Cuts.from_list(f.pop("cuts")), **f) for f in flavours_yaml
+        }
+        assert len(flavours_dict) == len(flavours_yaml), "Duplicate flavour names detected"
+
+        return cls(flavours_dict)
+
+
+Flavours = FlavourContainer.from_yaml()

ftag/flavours.yaml

@@ -58,11 +58,6 @@
   cuts: ["R10TruthLabel_R22v1 == 12"]
   colour: "#B45F06"
   category: xbb
-- name: tqqb
-  label: Fully Contained Top
-  cuts: ["R10TruthLabel_R22v1 == 1"]
-  colour: "#A300A3"
-  category: xbb
 - name: top
   label: Inclusive Top
   cuts: ["R10TruthLabel_R22v1 in (1,6,7)"]
@@ -74,6 +69,23 @@
   colour: "#38761D"
   category: xbb
 
+# extended Xbb tagging
+- name: tqqb
+  label: Fully Contained Top
+  cuts: ["R10TruthLabel_R22v1 == 1"]
+  colour: "#A300A3"
+  category: xbb-extended
+- name: wqq_from_t
+  label: Fully Contained W->qq from Top
+  cuts: ["R10TruthLabel_R22v1 == 6"]
+  colour: "indigo"
+  category: xbb-extended
+- name: other_from_t
+  label: Other Matched from Top
+  cuts: ["R10TruthLabel_R22v1 == 7"]
+  colour: "purple"
+  category: xbb-extended
+
 # partonic labelling
 - name: upjets
   label: $u$-jets

ftag/hdf5/h5reader.py

@@ -354,6 +354,11 @@ class H5Reader:
         int
             Estimated number of jets available after selection cuts, rounded down.
         """
+        # reset rngs to ensure same jets are used for each sample
+        self.rng = np.random.default_rng(42)
+        for r in self.readers:
+            r.rng = np.random.default_rng(42)
+
         # if equal jets is True, available jets is based on the smallest sample
         if self.equal_jets:
             num_jets = []

ftag/hdf5/h5split.py

@@ -9,7 +9,8 @@ import h5py
 from ftag.hdf5 import H5Reader, H5Writer
 
 
-class HelpFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter): ...
+class HelpFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
+    ...
 
 
 def parse_args(args):

ftag/mock.py

@@ -21,6 +21,7 @@ JET_VARS = [
     ("n_tracks", "i4"),
     ("HadronConeExclTruthLabelID", "i4"),
     ("HadronConeExclTruthLabelPt", "f4"),
+    ("R10TruthLabel_R22v1", "i4"),
     ("n_truth_promptLepton", "i4"),
     ("flavour_label", "i4"),
 ]
@@ -71,6 +72,23 @@ def get_mock_scores(labels: np.ndarray):
     return u2s(scores, dtype=np.dtype([(name, "f4") for name in cols]))
 
 
+def get_mock_xbb_scores(labels: np.ndarray):
+    rng = np.random.default_rng(42)
+    scores = np.zeros((len(labels), 4))
+    for label, count in zip(*np.unique(labels, return_counts=True)):
+        if label == 11:
+            scores[labels == label] = rng.normal(loc=[1, 0, 0, 0], scale=1, size=(count, 4))
+        elif label == 12:
+            scores[labels == label] = rng.normal(loc=[0, 1, 0, 0], scale=1, size=(count, 4))
+        elif label == 1:
+            scores[labels == label] = rng.normal(loc=[0, 0, 1, 0], scale=1, size=(count, 4))
+        elif label == 10:
+            scores[labels == label] = rng.normal(loc=[0, 0, 0, 1], scale=1, size=(count, 4))
+    scores = softmax(scores, axis=1)
+    cols = [f"MockXbbTagger_p{x}" for x in ["hbb", "hcc", "top", "qcd"]]
+    return u2s(scores, dtype=np.dtype([(name, "f4") for name in cols]))
+
+
 def get_mock_file(
     num_jets=1000,
     fname: str | None = None,
@@ -83,6 +101,7 @@ def get_mock_file(
     jets = u2s(rng.random((num_jets, len(JET_VARS))), jets_dtype)
     jets["HadronConeExclTruthLabelID"] = rng.choice([0, 4, 5, 15], size=num_jets)
     jets["flavour_label"] = rng.choice([0, 4, 5], size=num_jets)
+    jets["R10TruthLabel_R22v1"] = rng.choice([1, 10, 11, 12], size=num_jets)
     jets["pt"] *= 400e3
     jets["mass"] *= 50e3
     jets["eta"] = (jets["eta"] - 0.5) * 6.0
@@ -91,7 +110,8 @@ def get_mock_file(
 
     # add tagger scores
     scores = get_mock_scores(jets["HadronConeExclTruthLabelID"])
-    jets = join_structured_arrays([jets, scores])
+    xbb_scores = get_mock_xbb_scores(jets["R10TruthLabel_R22v1"])
+    jets = join_structured_arrays([jets, scores, xbb_scores])
 
     # create a tempfile in a new folder
     if fname is None:

ftag/vds.py

@@ -62,10 +62,24 @@ def create_virtual_file(
     if not overwrite and out_fname.is_file():
         return out_fname
 
+    # identify common groups across all files
+    common_groups: set[str] = set()
+    for fname in fnames:
+        with h5py.File(fname) as f:
+            groups = set(f.keys())
+            common_groups = groups if not common_groups else common_groups.intersection(groups)
+
+    if not common_groups:
+        raise ValueError("No common groups found across files")
+
+    print("Common groups found:")
+    for group in common_groups:
+        print(f"  {group}")
+
     # create virtual file
     out_fname.parent.mkdir(exist_ok=True)
     with h5py.File(out_fname, "w") as f:
-        for group in h5py.File(fnames[0]):
+        for group in common_groups:
             layout = get_virtual_layout(fnames, group)
             f.create_virtual_dataset(group, layout)
             attrs_dict: dict = {}

ftag/wps/discriminant.py

@@ -5,16 +5,38 @@ import numpy as np
 from ftag.flavour import Flavour, Flavours
 
 
-def btag_discriminant(pb, pc, pu, fc=0.1, epsilon=1e-10):
+def btag_discriminant(jets, tagger, fc=0.1, epsilon=1e-10):
+    pb, pc, pu = (jets[f"{tagger}_pb"], jets[f"{tagger}_pc"], jets[f"{tagger}_pu"])
     return np.log((pb + epsilon) / ((1.0 - fc) * pu + fc * pc + epsilon))
 
 
-def ctag_discriminant(pb, pc, pu, fb=0.2, epsilon=1e-10):
+def ctag_discriminant(jets, tagger, fb=0.2, epsilon=1e-10):
+    pb, pc, pu = (jets[f"{tagger}_pb"], jets[f"{tagger}_pc"], jets[f"{tagger}_pu"])
     return np.log((pc + epsilon) / ((1.0 - fb) * pu + fb * pb + epsilon))
 
 
+def hbb_discriminant(jets, tagger, ftop=0.25, fhcc=0.02, epsilon=1e-10):
+    phbb = jets[f"{tagger}_phbb"]
+    phcc = jets[f"{tagger}_phcc"]
+    ptop = jets[f"{tagger}_ptop"]
+    pqcd = jets[f"{tagger}_pqcd"]
+    return np.log(phbb / (ftop * ptop + fhcc * phcc + (1 - ftop - fhcc) * pqcd + epsilon))
+
+
+def hcc_discriminant(jets, tagger, ftop=0.25, fhbb=0.3, epsilon=1e-10):
+    phbb = jets[f"{tagger}_phbb"]
+    phcc = jets[f"{tagger}_phcc"]
+    ptop = jets[f"{tagger}_ptop"]
+    pqcd = jets[f"{tagger}_pqcd"]
+    return np.log(phcc / (ftop * ptop + fhbb * phbb + (1 - ftop - fhbb) * pqcd + epsilon))
+
+
 def get_discriminant(
-    jets: np.ndarray, tagger: str, signal: Flavour | str, fx: float, epsilon: float = 1e-10
+    jets: np.ndarray,
+    tagger: str,
+    signal: Flavour | str,
+    fx: float | tuple[float, ...],
+    epsilon: float = 1e-10,
 ):
     """Calculate the b-tag or c-tag discriminant for a given tagger.
 
@@ -25,9 +47,9 @@ def get_discriminant(
     tagger : str
         Name of the tagger
     signal : Flavour
-        Signal flavour (bjets or cjets)
+        Signal flavour (bjets/cjets or hbb/hcc)
     fx : float, optional
-        Value fb or fc
+        Value fb or fc (fhbb or fhcc and ftop for Xbb)
     epsilon : float, optional
         Small number to avoid division by zero, by default 1e-10
 
@@ -36,9 +58,17 @@ def get_discriminant(
     np.ndarray
         Array of discriminant values.
     """
-    pb, pc, pu = (jets[f"{tagger}_pb"], jets[f"{tagger}_pc"], jets[f"{tagger}_pu"])
-    if Flavours[signal] == Flavours.bjets:
-        return btag_discriminant(pb, pc, pu, fx, epsilon)
-    if Flavours[signal] == Flavours.cjets:
-        return ctag_discriminant(pb, pc, pu, fx, epsilon)
-    raise ValueError(f"Signal flavour must be bjets or cjets, not {signal}")
+    if not isinstance(fx, tuple | list):
+        fx = (fx,)
+    tagger_funcs = {
+        "bjets": btag_discriminant,
+        "cjets": ctag_discriminant,
+        "hbb": hbb_discriminant,
+        "hcc": hcc_discriminant,
+    }
+
+    func = tagger_funcs.get(str(Flavours[signal]), None)
+    if func is None:
+        raise ValueError(f"Signal flavour must be among {list(tagger_funcs.keys())}, not {signal}")
+
+    return func(jets, tagger, *fx, epsilon)  # type: ignore

ftag/wps/working_points.py

@@ -36,7 +36,6 @@ def parse_args(args):
         nargs="+",
         type=float,
         help="efficiency working point(s). If -r is specified, values should be 1/efficiency",
-        default=[60, 70, 77, 85],
     )
     parser.add_argument(
         "-t",
@@ -58,17 +57,24 @@ def parse_args(args):
         "-s",
         "--signal",
         default="bjets",
-        choices=["bjets", "cjets"],
+        choices=["bjets", "cjets", "hbb", "hcc"],
         type=str,
-        help='signal flavour ("bjets" or "cjets")',
+        help='signal flavour ("bjets" or "cjets" for b-tagging, "hbb" or "hcc" for Xbb)',
     )
     parser.add_argument(
         "-r",
         "--rejection",
         default=None,
-        choices=["ujets", "cjets", "bjets"],
+        choices=["ujets", "cjets", "bjets", "hbb", "hcc", "top", "qcd"],
         help="use rejection of specified background class to determine working points",
     )
+    parser.add_argument(
+        "-d",
+        "--disc_cuts",
+        nargs="+",
+        type=float,
+        help="D_x value(s) to calculate efficiency at",
+    )
     parser.add_argument(
         "-n",
         "--num_jets",
@@ -96,6 +102,11 @@ def parse_args(args):
         type=Path,
         help="save results to yaml instead of printing",
     )
+    parser.add_argument(
+        "--xbb",
+        action="store_true",
+        help="Enable Xbb tagging which expects two fx values ftop and fhcc/fhbb for each tagger",
+    )
 
     return parser.parse_args(args)
 
@@ -111,13 +122,18 @@ def get_eff_rej(jets, disc, wp, flavs):
 
 
 def get_working_points(args=None):
-    args = parse_args(args)
-
-    if len(args.tagger) != len(args.fx):
-        raise ValueError("Must provide fb/fc for each tagger")
+    if args.xbb:
+        if len(args.fx) != 2 * len(args.tagger):
+            raise ValueError("For Xbb tagging, each tagger must have two fx values")
+        fx_values = list(zip(args.fx[::2], args.fx[1::2]))
+    else:
+        if len(args.fx) != len(args.tagger):
+            raise ValueError("Number of taggers must match number of fx values")
+        fx_values = [(fx,) for fx in args.fx]
 
     # setup cuts and variables
-    flavs = Flavours.by_category("single-btag")
+    flavs = Flavours.by_category("single-btag") if not args.xbb else Flavours.by_category("xbb")
+
     default_cuts = Cuts.from_list(["eta > -2.5", "eta < 2.5"])
     ttbar_cuts = Cuts.from_list(args.ttbar_cuts) + default_cuts
     zprime_cuts = Cuts.from_list(args.zprime_cuts) + default_cuts
@@ -134,7 +150,7 @@ def get_working_points(args=None):
 
     # loop over taggers
     out = {}
-    for tagger, fx in zip(args.tagger, args.fx):
+    for tagger, fx in zip(args.tagger, fx_values):
         out[tagger] = {"signal": args.signal, "fx": fx}
 
         # calculate discriminant
@@ -168,10 +184,76 @@ def get_working_points(args=None):
         return out
 
 
-def main():
-    out = get_working_points()
+def get_rej_eff_at_disc(jets, tagger, signal, fx, disc_cuts):
+    disc = get_discriminant(jets, tagger, signal, fx)
+    d = {}
+    flavs = Flavours.by_category("single-btag")
+    for dcut in disc_cuts:
+        d[str(dcut)] = {"eff": {}, "rej": {}}
+        for f in flavs:
+            e_discs = disc[f.cuts(jets).idx]
+            eff = sum(e_discs > dcut) / len(e_discs)
+            d[str(dcut)]["eff"][str(f)] = float(f"{eff:.3g}")
+            d[str(dcut)]["rej"][str(f)] = 1 / float(f"{eff:.3g}")
+    return d
+
+
+def get_efficiencies(args=None):
+    if len(args.tagger) != len(args.fx):
+        raise ValueError("Must provide fb/fc for each tagger")
+
+    fx_values = [(fx,) for fx in args.fx]
+    # setup cuts and variables
+    flavs = Flavours.by_category("single-btag")
+    default_cuts = Cuts.from_list(["eta > -2.5", "eta < 2.5"])
+    ttbar_cuts = Cuts.from_list(args.ttbar_cuts) + default_cuts
+    zprime_cuts = Cuts.from_list(args.zprime_cuts) + default_cuts
+    all_vars = next(iter(flavs)).cuts.variables
+    for tagger in args.tagger:
+        all_vars += [f"{tagger}_{f.px}" for f in flavs if "tau" not in f.px]
+
+    # load jets
+    reader = H5Reader(args.ttbar)
+    jets = reader.load({"jets": all_vars}, args.num_jets, cuts=ttbar_cuts)["jets"]
+    if args.zprime:
+        zp_reader = H5Reader(args.zprime)
+        zp_jets = zp_reader.load({"jets": all_vars}, args.num_jets, cuts=zprime_cuts)["jets"]
+
+    # loop over taggers
+    out = {}
+    for tagger, fx in zip(args.tagger, fx_values):
+        out[tagger] = {"signal": args.signal, "fx": fx}
+
+        out[tagger]["ttbar"] = get_rej_eff_at_disc(jets, tagger, args.signal, fx, args.disc_cuts)
+        if args.zprime:
+            out[tagger]["zprime"] = get_rej_eff_at_disc(
+                zp_jets, tagger, args.signal, fx, args.disc_cuts
+            )
+
+    if args.outfile:
+        with open(args.outfile, "w") as f:
+            yaml.dump(out, f, sort_keys=False)
+            return None
+    else:
+        return out
+
+
+def main(args=None):
+    args = parse_args(args)
+
+    if args.effs and args.disc_cuts:
+        raise ValueError("Cannot specify both --effs and --disc_cuts")
+
+    if args.effs:
+        out = get_working_points(args)
+    elif args.disc_cuts:
+        out = get_efficiencies(args)
+    else:
+        raise ValueError("Must specify either --effs or --disc_cuts")
     if out:
         print(yaml.dump(out, sort_keys=False))
+        return out
+    return None
 
 
 if __name__ == "__main__":

atlas_ftag_tools-0.1.13.dist-info/RECORD

@@ -1,23 +0,0 @@
-ftag/__init__.py,sha256=gcWw-kYu7WI13uQZ_ulcS2T--iUjHXXFUb4ZaDzASBs,629
-ftag/cuts.py,sha256=RYAfK3MkEhYhlKQFWQTKu72ZrUwlExFeT8IWLSIgeTU,2798
-ftag/flavour.py,sha256=qvAPWPDdFGoTsADhqUB1PEFHrM2NekiDlLM0Tlx9w0E,2456
-ftag/flavours.yaml,sha256=RT1LooN-75MlZ6k1RhFZySickv1er_1qIxoa94HTGy4,5028
-ftag/git_check.py,sha256=TvF502eqDrYzhI-SgruVolx1BPJi-J0mswc4pmgaYY8,1621
-ftag/mock.py,sha256=EZ-2YtFf36mL95cLzoezxzH2p4WfG6Nad6gM9f6nlsM,3828
-ftag/region.py,sha256=-WxdC0Gy9zz3zEJ2pN779RcxXPG-QEROuMwMoP-Qs0g,353
-ftag/sample.py,sha256=cd-rNHsEY2aWSZdy3V4bOKi3aDMtHTCpjXS8Hl9zwUY,2597
-ftag/transform.py,sha256=uEGGJSnqoKOzLYQv650XdK_kDNw4Aw-5dc60z9Dp_y0,3963
-ftag/vds.py,sha256=l2JttxscusBWUSog8SjSkhPn-4lhOLzZmLaqe4hGiS0,2929
-ftag/hdf5/__init__.py,sha256=pZva2TI8nvpBwoawcm_ucVZbGsQJW_u8GGoJgt5mKEw,354
-ftag/hdf5/h5move.py,sha256=1XxiJZ96DYSp8JF0ry3lbRSQaFX72DjUV5vBA6hYw-0,873
-ftag/hdf5/h5reader.py,sha256=D3a9l4jVnvJPlp9fprvnlp2arHPRl_1PT5SEDFO0i_U,13390
-ftag/hdf5/h5split.py,sha256=QICjC41GyXCQkaP6AqBjVxicmP2yEULVVHktvkq9bY4,2504
-ftag/hdf5/h5utils.py,sha256=wjbAmFY5GoFkWW_AvEKTPbwYMFroHKKFuIcehd91dhM,3222
-ftag/hdf5/h5writer.py,sha256=5jm3vSk4m77lFSUyWm-i_y_USzQRVoKpLL8F_cii65Q,4826
-ftag/wps/discriminant.py,sha256=b41PrrGSRwYKsqBaQgbi6wGLGJHnm-tYEpvyszQPy_4,1364
-ftag/wps/working_points.py,sha256=70UU4xlwkTRKX2HXZ9VE2tjcwWj0GuFrl-a01SvEnSY,5006
-atlas_ftag_tools-0.1.13.dist-info/METADATA,sha256=ahnqgms5ZEIkV_YDa6LWwCPYoPy3dwbLSijWgXQhvWA,4591
-atlas_ftag_tools-0.1.13.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-atlas_ftag_tools-0.1.13.dist-info/entry_points.txt,sha256=LfVLsZHQolqbPnwPgtmc5IQTh527BKkN2v-IpXWTNHw,137
-atlas_ftag_tools-0.1.13.dist-info/top_level.txt,sha256=qiYQuKcAvMim-31FwkT3MTQu7WQm0s58tPAia5KKWqs,5
-atlas_ftag_tools-0.1.13.dist-info/RECORD,,