PFASGroups 3.4.0__tar.gz → 3.4.2__tar.gz

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/PFASGroups/HalogenGroupModel.py

@@ -156,8 +156,15 @@ class HalogenGroup():
             # prepare halogens (accepts list, str or None)
             if isinstance(self.componentHalogens,list) and len(set(self.componentHalogens).intersection(['F','Cl','Br','I','H'])) == 0:
                 raise ValueError(f"Invalid componentHalogens for HalogenGroup '{self.name}' (ID: {self.id})")
+            _halogens_inferred = False
             if self.componentHalogens is None:
-                self.componentHalogens = ['F','Cl','Br','I']
+                # Derive from whichever halogens have component SMARTS defined in the
+                # available componentSmartss.  Fall back to real halogens only (no H)
+                # when the data provides no guidance.
+                _hal_order = ['F', 'Cl', 'Br', 'I', 'H']
+                _inferred = [h for h in _hal_order if h in componentSmarts_dict]
+                self.componentHalogens = _inferred if _inferred else ['F', 'Cl', 'Br', 'I']
+                _halogens_inferred = True
             elif isinstance(self.componentHalogens, str) and self.componentHalogens in ['F','Cl','Br','I','H']:
                 self.componentHalogens = [self.componentHalogens]
             if self.componentSaturation is None:
@@ -172,11 +179,17 @@ class HalogenGroup():
                 self.componentForm = 'alkyl'
             for halogen in self.componentHalogens:
                 if halogen not in componentSmarts_dict:
+                    if _halogens_inferred:
+                        continue
                     raise ValueError(f"No component SMARTS available for halogen '{halogen}' in HalogenGroup '{self.name}' (ID: {self.id})")
                 if self.componentForm not in componentSmarts_dict[halogen]:
+                    if _halogens_inferred:
+                        continue
                     raise ValueError(f"No component SMARTS available for form '{self.componentForm}' and halogen '{halogen}' in HalogenGroup '{self.name}' (ID: {self.id})")
                 for saturation in self.componentSaturation:
                     if saturation not in componentSmarts_dict[halogen][self.componentForm]:
+                        if _halogens_inferred:
+                            continue
                         raise ValueError(f"No component SMARTS available for saturation '{saturation}', form '{self.componentForm}', halogen '{halogen}' in HalogenGroup '{self.name}' (ID: {self.id})")
                     new_CS.append(componentSmarts_dict[halogen][self.componentForm][saturation])
             self.componentSmarts = new_CS

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/PFASGroups/__init__.py

@@ -15,7 +15,17 @@ from .fragmentation import generate_degradation_products
 # PFASEmbedding (dict subclass, primary) must be imported after embeddings to take precedence
 from .PFASEmbeddings import PFASEmbedding, PFASEmbeddingSet, EmbeddingArray, ResultsModel, MoleculeResult, generate_fingerprint
 from .prioritise import prioritise_molecules, prioritize_molecules, get_priority_statistics
+from .group_features import (
+    extract_group_features, GroupFeatureResult,
+    PER_GROUP_IDS, POLY_GROUP_IDS, HALOGENS_ORDER,
+    GENERIC_GROUP_VOCAB, GENERIC_GROUP_NAMES,
+)
 __version__ = "3.2.0"
 __all__ = ['HalogenGroup', 'PFASDefinition', 'parse_smiles', 'parse_mols','parse_mol', 'parse_groups_in_mol', 'parse_from_database', 'setup_halogen_groups_database', 'plot_HalogenGroups', 'plot_mol','plot_mols', 'FINGERPRINT_PRESETS', 'PFASFingerprint', 'generate_fingerprint', 'get_compiled_componentSMARTSs', 'get_componentSMARTSs', 'get_HalogenGroups', 'get_compiled_HalogenGroups', 'get_compiled_PFASGroups', 'get_PFASDefinitions' ,'ComponentsSolver', 'generate_homologues', 'generate_degradation_products',"rdkit_disable_log","load_HalogenGroups", "HALOGEN_GROUPS_FILE", "_match_wildcard_groups_in_mol"]
 __all__.extend(['PFASEmbedding', 'PFASEmbeddingSet', 'EmbeddingArray', 'ResultsModel', 'MoleculeResult', 'prioritise_molecules', 'prioritize_molecules', 'get_priority_statistics'])
 __all__.extend(['HomologueSeries', 'HomologueEntry'])
+__all__.extend([
+    'extract_group_features', 'GroupFeatureResult',
+    'PER_GROUP_IDS', 'POLY_GROUP_IDS', 'HALOGENS_ORDER',
+    'GENERIC_GROUP_VOCAB', 'GENERIC_GROUP_NAMES',
+])

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/PFASGroups/data/PFAS_definitions_smarts.json

@@ -63,12 +63,12 @@
         "id": 3,
         "name": "OPPT 2023",
         "smarts": [
-            "[#6H0X4](F)(F)[#6H0X4](F)",
-            "[#6](F)(F)([F,#8,#6H0X4])[#8][#6](F)(F)[F,#8,#6H0X4]",
-            "[#6](F)(F)(F)[#6]([#6](F)(F)F)([F,#6H0X4])[F,#6H0X4]"
+            "[#6X4](F)(F)[#6X4](F)",
+            "[#6](F)(F)([F,#8,#6X4])[#8][#6](F)(F)[F,#8,#6X4]",
+            "[#6](F)(F)(F)[#6]([#6](F)(F)F)([F,#6X4])[F,#6X4]"
         ],
         "fluorineRatio": null,
-        "description": "Three inclusion criteria.",
+        "description": "Three inclusion criteria. R groups are unconstrained per the final 2023 rule (40 CFR 705.3) -- the 2021 proposal's \"none of the R groups can be hydrogen\" language was dropped when finalized, so R positions (and the non-defining valence on the backbone CF2/CF carbons) may be H. Validated against EPA's published PFAS8a7v3 CompTox list: 99.96% coverage (13,035/13,040) with H unconstrained, vs 91.50% with H0 enforced.",
         "test": {
             "category": "definition",
             "examples": {
@@ -77,13 +77,13 @@
                     "C(F)(F)C(F)(F)C(F)(F)C",
                     "C(F)(F)(F)C(F)(F)OC(F)(F)C(F)(F)F",
                     "C(F)(F)(C(F)(F)F)C(F)(F)C(F)(F)F",
-                    "C(F)(F)(F)C(OC)(F)C(F)(F)F"
+                    "C(F)(F)(F)C(OC)(F)C(F)(F)F",
+                    "FC(F)C(F)F"
                 ],
                 "negatives": [
                     "CCCCCC",
                     "C(F)CCC",
                     "CC(F)(F)C",
-                    "FC(F)C(F)F",
                     "C1=CC=CC=C1"
                 ]
             }
@@ -166,5 +166,28 @@
                 ]
             }
         }
+    },
+    {
+        "id": 6,
+        "name": "OPPT 2021",
+        "smarts": [
+            "[#6H0X4](F)(F)[#6H0X4](F)"
+        ],
+        "fluorineRatio": null,
+        "description": "R-(CF2)-CF(R')R'', where the CF2 and CF moieties are saturated carbons and none of the R groups can be hydrogen (2021 proposed definition; superseded by OPPT 2023, which drops this H restriction).",
+        "test": {
+            "category": "definition",
+            "examples": {
+                "positives": [
+                    "C(F)(F)(F)C(F)(F)C(F)(F)F"
+                ],
+                "negatives": [
+                    "CCCCCC",
+                    "C(F)CCC",
+                    "CC(F)(F)C",
+                    "C1=CC=CC=C1"
+                ]
+            }
+        }
     }
 ]

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/PFASGroups/data/component_smarts_halogens.json

@@ -143,8 +143,23 @@
         "alkyl": {
             "per": {
                 "name": "Alkyl",
-                "component": "[CH2]",
-                "end": "[CH3]"
+                "component": "[CH2!$([#6][F,Cl,Br,I]),CH3$([CH3][#6])!$([#6][F,Cl,Br,I])]",
+                "end": "[CH3]",
+                "constraints": {"gte": {"H": 2}}
+            }
+        },
+        "cyclic": {
+            "per": {
+                "name": "Cyclic alkyl",
+                "component": "[#6aX4R$([#6aR]([#6aR!$([#6][F,Cl,Br,I])])([#6aR!$([#6][F,Cl,Br,I])])[!$([#6][F,Cl,Br,I])][!$([#6][F,Cl,Br,I])])]",
+                "constraints": {"gte": {"H": 2}}
+            }
+        },
+        "aryl": {
+            "per": {
+                "name": "Aryl",
+                "component": "[#6aX3R$([#6aR]([#6aR!$([#6][F,Cl,Br,I])])[#6aR!$([#6][F,Cl,Br,I])])!$([#6][F,Cl,Br,I])]",
+                "constraints": {"gte": {"H": 1}}
             }
         }
     }

pfasgroups-3.4.2/PFASGroups/group_features.py

@@ -0,0 +1,393 @@
+"""Structured feature extraction from PFASGroups halogen group detection.
+
+This module provides :func:`extract_group_features`, a single public entry
+point that runs the necessary :func:`~PFASGroups.parser.parse_mol` calls and
+returns a :class:`GroupFeatureResult` with four named feature dictionaries
+covering the following four group categories:
+
+- **Polyhalogenated groups** (ids 35, 38, 45): aggregate match counts
+- **Perhalogenated groups** (ids 34, 37, 44): per-halogen max component sizes
+- **Alkyl chain (H pseudo-halogen)** aggregates: convenience view of the H
+  column of perhalogenated results
+- **Generic functional groups** (ids 29-76): wildcard bag-of-groups counts
+
+The six component groups (34/35/37/38/44/45) are excluded from wildcard
+matching by design, so they never appear in the generic-group counts.
+
+Example
+-------
+>>> from rdkit import Chem
+>>> from PFASGroups import extract_group_features
+>>> mol = Chem.MolFromSmiles("FC(F)(F)C(F)(F)C(F)(F)C(=O)O")  # PFOA-like
+>>> r = extract_group_features(mol)
+>>> r.poly_counts
+{'poly_alkyl': 1.0, 'poly_aryl': 0.0, 'poly_cyclic': 0.0}
+>>> r.per_halogen_sizes['g34_F']  # longest perfluoroalkyl component (carbons)
+4.0
+>>> r.h_chain_sizes
+{'alkyl_H': 0.0, 'aryl_H': 0.0, 'cyclic_H': 0.0}
+>>> len(r.to_array())  # 3 + 15 + 48
+66
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Union
+
+import numpy as np
+from rdkit import Chem
+
+from .parser import parse_mol as _parse_mol  # type: ignore[attr-defined]
+from .getter import get_compiled_HalogenGroups as _get_compiled_HalogenGroups
+
+# ---------------------------------------------------------------------------
+# Public constants
+# ---------------------------------------------------------------------------
+
+#: Group IDs for perhalogenated groups (alkyl, aryl, cyclic).
+#: These groups require *all* halogen-bearing carbons to carry only one halogen
+#: type.  Each match is attributed to a single halogen (or H for alkyl chains).
+PER_GROUP_IDS: list[int] = [34, 37, 44]
+
+#: Group IDs for polyhalogenated groups (alkyl, aryl, cyclic).
+#: These groups allow a *mixture* of halogens and/or partial halogenation.
+#: Match counts are aggregated across all halogens.
+POLY_GROUP_IDS: list[int] = [35, 38, 45]
+
+#: Halogen types recognised in :attr:`GroupFeatureResult.per_halogen_sizes`.
+#: ``'H'`` is the pseudo-halogen used to detect un-substituted alkyl chains
+#: (perhalogenated-alkyl, group 34) via :class:`~PFASGroups.ComponentsSolverModel.ComponentsSolver`.
+HALOGENS_ORDER: list[str] = ["F", "Cl", "Br", "I", "H"]
+
+#: Ordered list of group IDs covered by :attr:`GroupFeatureResult.generic_groups`.
+#: Ids {34, 35, 37, 38, 44, 45} are excluded from wildcard matching and will
+#: always be zero in this vector.
+GENERIC_GROUP_VOCAB: list[int] = list(range(29, 77))  # 48 entries
+
+#: Human-readable names for every group id in :data:`GENERIC_GROUP_VOCAB`.
+GENERIC_GROUP_NAMES: dict[int, str] = {
+    29: "acrylate",
+    30: "acyl halide",
+    31: "alcohol",
+    32: "aldehyde",
+    33: "alkene",
+    34: "perhalogenated alkyl",
+    35: "polyhalogenated alkyl",
+    36: "alkyne",
+    37: "perhalogenated aryl compounds",
+    38: "polyhalogenated aryl compounds",
+    39: "benzodioxole",
+    40: "benzoyl peroxydes",
+    41: "bromide",
+    42: "carboxylic acid",
+    43: "chloride",
+    44: "perhalogenated cyclic compounds",
+    45: "polyhalogenated cyclic compounds",
+    46: "ester",
+    47: "ether",
+    48: "fluoride",
+    49: "glucuronate",
+    50: "iodide",
+    51: "ketone",
+    52: "methacrylate",
+    53: "peroxydes",
+    54: "side-chain aromatics",
+    55: "sulfenic acid",
+    56: "sulfenyl halide",
+    57: "sulfinic acid",
+    58: "sulfinyl amido sulfonic acid",
+    59: "sulfonamide",
+    60: "sulfonamidoethanol",
+    61: "sulfonic acid",
+    62: "sulfonyl halide",
+    63: "sulfonyl propanoic acid",
+    64: "sulfuric acid",
+    65: "thioester keto dicarboxylic acid",
+    66: "thiocyanic acid",
+    67: "phosphinic acid",
+    68: "phosphonic acid",
+    69: "amide",
+    70: "amine",
+    71: "heterocyclic azine",
+    72: "heterocyclic azole",
+    73: "betaine",
+    74: "glycine",
+    75: "trichlorosilane",
+    76: "silane",
+}
+
+# ---------------------------------------------------------------------------
+# Internal state
+# ---------------------------------------------------------------------------
+
+_COMPONENT_GROUPS: list | None = None  # cached list of HalogenGroups {34..45}
+_GENERIC_GROUP_INDEX: dict[int, int] = {gid: i for i, gid in enumerate(GENERIC_GROUP_VOCAB)}
+_HAL_TO_COL: dict[str, int] = {h: i for i, h in enumerate(HALOGENS_ORDER)}
+_PER_GID_TO_ROW: dict[int, int] = {34: 0, 37: 1, 44: 2}
+_POLY_GID_TO_IDX: dict[int, int] = {35: 0, 38: 1, 45: 2}
+
+# Short labels used in h_chain_sizes
+_H_CHAIN_KEYS: list[str] = ["alkyl_H", "aryl_H", "cyclic_H"]
+# Corresponding per_halogen_sizes keys (H column of each per group)
+_H_CHAIN_PHS_KEYS: list[str] = ["g34_H", "g37_H", "g44_H"]
+
+
+def _get_component_groups() -> list:
+    """Return a cached list of :class:`~PFASGroups.HalogenGroup` objects with ids in ``{34,35,37,38,44,45}``."""
+    global _COMPONENT_GROUPS
+    if _COMPONENT_GROUPS is None:
+        _ids = {34, 35, 37, 38, 44, 45}
+        _COMPONENT_GROUPS = [g for g in _get_compiled_HalogenGroups() if g.id in _ids]
+    return _COMPONENT_GROUPS
+
+
+# ---------------------------------------------------------------------------
+# GroupFeatureResult
+# ---------------------------------------------------------------------------
+
+@dataclass
+class GroupFeatureResult:
+    """Structured feature extraction result for a single molecule.
+
+    This dataclass groups features from two :func:`~PFASGroups.parser.parse_mol`
+    calls into four semantically distinct dictionaries.  It is returned by
+    :func:`extract_group_features`.
+
+    Attributes
+    ----------
+    poly_counts : dict[str, float]
+        Match counts for **polyhalogenated** groups (ids 35, 38, 45), aggregated
+        across all halogens (F, Cl, Br, I, H).  Keys: ``'poly_alkyl'``,
+        ``'poly_aryl'``, ``'poly_cyclic'``.
+
+    per_halogen_sizes : dict[str, float]
+        Maximum carbon-component size for **perhalogenated** groups (ids 34, 37,
+        44) resolved per halogen.  Keys follow the pattern ``'g{id}_{hal}'``
+        where *id* is in ``{34, 37, 44}`` and *hal* is in
+        ``['F', 'Cl', 'Br', 'I', 'H']``.  Zero when no match is found.
+
+    h_chain_sizes : dict[str, float]
+        Convenience view of the ``'H'`` column of :attr:`per_halogen_sizes`:
+        the largest un-substituted alkyl / aryl / cyclic component detected via
+        the H pseudo-halogen mechanism.  Keys: ``'alkyl_H'``, ``'aryl_H'``,
+        ``'cyclic_H'``.  **Not included in** :meth:`to_array`.
+
+    generic_groups : dict[str, float]
+        Wildcard functional-group match counts for group ids 29-76.  Keys:
+        ``'g29'`` … ``'g76'``.  Ids ``{34, 35, 37, 38, 44, 45}`` are excluded
+        from wildcard matching and will always be zero.
+    """
+
+    poly_counts: dict[str, float] = field(default_factory=dict)
+    per_halogen_sizes: dict[str, float] = field(default_factory=dict)
+    h_chain_sizes: dict[str, float] = field(default_factory=dict)
+    generic_groups: dict[str, float] = field(default_factory=dict)
+
+    def to_array(self) -> np.ndarray:
+        """Return a fixed-length float32 array of shape ``(66,)``.
+
+        Layout::
+
+            [0:3]   poly_counts    (poly_alkyl, poly_aryl, poly_cyclic)
+            [3:18]  per_halogen_sizes  (g34_F…g44_H, 3 groups × 5 halogens)
+            [18:66] generic_groups  (g29…g76, 48 entries)
+
+        Note
+        ----
+        :attr:`h_chain_sizes` is excluded from this array (it is a strict
+        subset of :attr:`per_halogen_sizes`).
+        """
+        poly = np.array(
+            [self.poly_counts[k] for k in ("poly_alkyl", "poly_aryl", "poly_cyclic")],
+            dtype=np.float32,
+        )
+        per_keys = [
+            f"g{gid}_{h}"
+            for gid in PER_GROUP_IDS
+            for h in HALOGENS_ORDER
+        ]
+        per = np.array([self.per_halogen_sizes[k] for k in per_keys], dtype=np.float32)
+        gen = np.array(
+            [self.generic_groups[f"g{gid}"] for gid in GENERIC_GROUP_VOCAB],
+            dtype=np.float32,
+        )
+        return np.concatenate([poly, per, gen])
+
+    def feature_names(self) -> list[str]:
+        """Return the 66 feature names in the same order as :meth:`to_array`.
+
+        Returns
+        -------
+        list[str]
+            Labels: ``['poly_alkyl', 'poly_aryl', 'poly_cyclic',
+            'g34_F', 'g34_Cl', …, 'g44_H', 'g29', 'g30', …, 'g76']``.
+        """
+        poly_names = ["poly_alkyl", "poly_aryl", "poly_cyclic"]
+        per_names = [
+            f"g{gid}_{h}"
+            for gid in PER_GROUP_IDS
+            for h in HALOGENS_ORDER
+        ]
+        gen_names = [f"g{gid}" for gid in GENERIC_GROUP_VOCAB]
+        return poly_names + per_names + gen_names
+
+    def __repr__(self) -> str:
+        nz_poly = sum(1 for v in self.poly_counts.values() if v)
+        nz_per = sum(1 for v in self.per_halogen_sizes.values() if v)
+        nz_gen = sum(1 for v in self.generic_groups.values() if v)
+        return (
+            f"GroupFeatureResult("
+            f"poly_counts={nz_poly} nonzero, "
+            f"per_halogen_sizes={nz_per} nonzero, "
+            f"generic_groups={nz_gen} nonzero)"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def extract_group_features(
+    mol: Union[Chem.Mol, str],
+) -> GroupFeatureResult:
+    """Extract structured halogen-group features for a single molecule.
+
+    Two :func:`~PFASGroups.parser.parse_mol` calls are made internally:
+
+    1. ``halogens=['H','F','Cl','Br','I']`` with the six component groups
+       (ids 34, 35, 37, 38, 44, 45) — populates :attr:`~GroupFeatureResult.poly_counts`
+       and :attr:`~GroupFeatureResult.per_halogen_sizes`.
+    2. ``halogens=['*']`` (wildcard) — populates
+       :attr:`~GroupFeatureResult.generic_groups`.
+
+    Parameters
+    ----------
+    mol : rdkit.Chem.Mol or str
+        RDKit molecule object or a SMILES string.
+
+    Returns
+    -------
+    GroupFeatureResult
+        Populated result object.  Call :meth:`~GroupFeatureResult.to_array` to
+        obtain a fixed-length float32 array of shape ``(66,)``.
+
+    Raises
+    ------
+    ValueError
+        If a SMILES string cannot be parsed by RDKit.
+    RuntimeError
+        If an unexpected error occurs during :func:`parse_mol`.
+
+    Examples
+    --------
+    >>> from rdkit import Chem
+    >>> from PFASGroups import extract_group_features
+    >>> pfoa = Chem.MolFromSmiles("FC(F)(F)C(F)(F)C(F)(F)C(=O)O")
+    >>> r = extract_group_features(pfoa)
+    >>> r.poly_counts
+    {'poly_alkyl': 1.0, 'poly_aryl': 0.0, 'poly_cyclic': 0.0}
+    >>> r.per_halogen_sizes['g34_F']
+    4.0
+    >>> r.h_chain_sizes
+    {'alkyl_H': 0.0, 'aryl_H': 0.0, 'cyclic_H': 0.0}
+    >>> arr = r.to_array()
+    >>> arr.shape
+    (66,)
+    >>> # Octane — only H alkyl chain detected
+    >>> octane = Chem.MolFromSmiles("CCCCCCCC")
+    >>> r2 = extract_group_features(octane)
+    >>> r2.h_chain_sizes['alkyl_H']
+    6.0
+    """
+    if isinstance(mol, str):
+        mol = Chem.MolFromSmiles(mol)
+        if mol is None:
+            raise ValueError(f"RDKit could not parse SMILES string.")
+
+    # --- Call 1: component groups with all halogens including H ---
+    emb_chain = _parse_mol(
+        mol,
+        halogens=["H", "F", "Cl", "Br", "I"],
+        pfas_groups=_get_component_groups(),
+        compute_component_metrics=False,
+    )
+
+    # --- Call 2: wildcard generic functional groups ---
+    emb_wc = _parse_mol(
+        mol,
+        halogens=["*"],
+        compute_component_metrics=False,
+    )
+
+    # ------------------------------------------------------------------
+    # Build poly_counts
+    # ------------------------------------------------------------------
+    poly_vals: dict[str, float] = {"poly_alkyl": 0.0, "poly_aryl": 0.0, "poly_cyclic": 0.0}
+    _poly_key = {35: "poly_alkyl", 38: "poly_aryl", 45: "poly_cyclic"}
+    for match in emb_chain.matches:
+        if not match.is_group:
+            continue
+        key = _poly_key.get(match.group_id)
+        if key is not None:
+            poly_vals[key] += 1.0
+
+    # ------------------------------------------------------------------
+    # Build per_halogen_sizes (15 entries: 3 groups × 5 halogens)
+    # ------------------------------------------------------------------
+    phs: dict[str, float] = {
+        f"g{gid}_{h}": 0.0
+        for gid in PER_GROUP_IDS
+        for h in HALOGENS_ORDER
+    }
+    for match in emb_chain.matches:
+        if not match.is_group:
+            continue
+        row = _PER_GID_TO_ROW.get(match.group_id)
+        if row is None:
+            continue
+        gid = PER_GROUP_IDS[row]
+        h_val = match.get("halogen")
+        hal_hits: list[str]
+        if isinstance(h_val, list):
+            hal_hits = [x for x in h_val if x in _HAL_TO_COL]
+        elif h_val in _HAL_TO_COL:
+            hal_hits = [h_val]
+        else:
+            continue
+        max_size = 0.0
+        for comp in match.components:
+            s = comp.data.get("size", 0) or 0
+            if s > max_size:
+                max_size = float(s)
+        for hal in hal_hits:
+            k = f"g{gid}_{hal}"
+            if max_size > phs[k]:
+                phs[k] = max_size
+
+    # ------------------------------------------------------------------
+    # Build h_chain_sizes (convenience subset: H column of per_halogen_sizes)
+    # ------------------------------------------------------------------
+    h_chain: dict[str, float] = {
+        "alkyl_H": phs["g34_H"],
+        "aryl_H": phs["g37_H"],
+        "cyclic_H": phs["g44_H"],
+    }
+
+    # ------------------------------------------------------------------
+    # Build generic_groups (48 entries, ids 29-76)
+    # ------------------------------------------------------------------
+    gen: dict[str, float] = {f"g{gid}": 0.0 for gid in GENERIC_GROUP_VOCAB}
+    for match in emb_wc.matches:
+        if match.get("halogen") != "*":
+            continue
+        gid = match.group_id
+        k = f"g{gid}"
+        if k in gen:
+            gen[k] += 1.0
+
+    return GroupFeatureResult(
+        poly_counts=poly_vals,
+        per_halogen_sizes=phs,
+        h_chain_sizes=h_chain,
+        generic_groups=gen,
+    )

{pfasgroups-3.4.0 → pfasgroups-3.4.2/PFASGroups.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PFASGroups
-Version: 3.4.0
+Version: 3.4.2
 Summary: A comprehensive cheminformatics package for automated detection, classification, and analysis of halogenated substances, with a focus on per- and polyfluoroalkyl substances (PFAS). Combines SMARTS pattern matching, molecular formula constraints, and graph-based pathfinding to identify 119 groups. Supports creations of embeddings with graph metrics for Machine Learning workflows.
 Author: Luc T. Miaz
 Author-email: "Luc T. Miaz" <luc@miaz.ch>
@@ -72,10 +72,48 @@ PFASGroups combines SMARTS pattern matching, molecular formula constraints, and
 ### Additional Tools
 - **Homologue Series Generation**: Iterative component shortening to explore theoretical chemical space
 - **Fingerprint Generation**: PFAS fingerprints for machine learning applications
+- **Group Feature Extraction**: Fixed-length named feature vectors for ML pipelines (see below)
 - **Visualization**: Assign and visualize PFAS groupings
 - **Multiple Interfaces**: Python API, command-line tool, and browser-based JavaScript version (RDKitJS)
 - **Batch Processing**: Efficient analysis of large chemical databases
 
+## Group Feature Extraction
+
+`extract_group_features` returns a structured `GroupFeatureResult` covering three
+chemically meaningful feature sets derived from the six component groups and the
+48 generic functional groups:
+
+```python
+from rdkit import Chem
+from PFASGroups import extract_group_features
+
+mol = Chem.MolFromSmiles("FC(F)(F)C(F)(F)C(F)(F)C(=O)O")  # PFOA-like
+r = extract_group_features(mol)
+
+# Polyhalogenated group match counts (groups 35/38/45, all halogens combined)
+print(r.poly_counts)
+# {'poly_alkyl': 1.0, 'poly_aryl': 0.0, 'poly_cyclic': 0.0}
+
+# Perhalogenated group max component sizes per halogen (groups 34/37/44 × F/Cl/Br/I/H)
+print(r.per_halogen_sizes['g34_F'])   # longest perfluoroalkyl chain (carbons)
+# 4.0
+
+# Alkyl chain size via H pseudo-halogen (convenience view of per_halogen_sizes H column)
+print(r.h_chain_sizes)  # octane: {'alkyl_H': 6.0, 'aryl_H': 0.0, 'cyclic_H': 0.0}
+
+# Generic functional groups (ids 29-76, wildcard)
+print({k: v for k, v in r.generic_groups.items() if v})
+# {'g42': 1.0, 'g48': 1.0}  →  carboxylic acid + fluoride
+
+# Fixed-length float32 array of shape (66,) for ML use
+arr = r.to_array()
+names = r.feature_names()  # matching labels
+```
+
+SMILES strings are accepted directly in addition to `rdkit.Chem.Mol` objects.
+See the [Group Feature Extraction](docs/group_features.rst) documentation page for
+the full feature layout, group ID table, and worked examples.
+
 ## Installation
 
 The recommended installation method is via pip.  RDKit must already be available in the target environment. It is recommended to use an environment manager (like Conda/Mamba, e.g [Miniforge](https://github.com/conda-forge/miniforge)) and install RDKit via 
@@ -454,7 +492,7 @@ h_group = HalogenGroup(
 )
 
 # Parse using H mode
-results = parse_smiles(smiles, halogens='H', pfas_groups=[h_group], bycomponent=True)
+results = parse_smiles(smiles, halogens='H', pfas_groups=[h_group])
 
 # Inspect H-component matches for the custom group
 h_matches = [m for m in results[0].matches if m.get('id') == 9990 and m.get('type') == 'HalogenGroup']
@@ -808,6 +846,9 @@ See [USER_GUIDE.md](USER_GUIDE.md) for comprehensive examples including:
 - Integration with pandas and scikit-learn
 
 ## Summary of changes by version
+- **Version 3.4.2**: Fixed ambiguity with OPPT 2023.
+
+- **Version 3.4.1**: Added generic embedding for non-halogenated specific compounds which includes wildcard-components functional groups and halogen component size. Fixed H components and added cyclic and aryl H components.
 
 - **Version 3.4.0**: Added H components (use in homologue series generation) and wildcard components to match generic functional groups (broader use than PFAS).
 

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/PFASGroups.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ PFASGroups/generate_homologues.py
 PFASGroups/generate_mol.py
 PFASGroups/generate_paper_figures.py
 PFASGroups/getter.py
+PFASGroups/group_features.py
 PFASGroups/homologue_series.py
 PFASGroups/parser.py
 PFASGroups/prioritise.py

{pfasgroups-3.4.0/PFASGroups.egg-info → pfasgroups-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PFASGroups
-Version: 3.4.0
+Version: 3.4.2
 Summary: A comprehensive cheminformatics package for automated detection, classification, and analysis of halogenated substances, with a focus on per- and polyfluoroalkyl substances (PFAS). Combines SMARTS pattern matching, molecular formula constraints, and graph-based pathfinding to identify 119 groups. Supports creations of embeddings with graph metrics for Machine Learning workflows.
 Author: Luc T. Miaz
 Author-email: "Luc T. Miaz" <luc@miaz.ch>
@@ -72,10 +72,48 @@ PFASGroups combines SMARTS pattern matching, molecular formula constraints, and
 ### Additional Tools
 - **Homologue Series Generation**: Iterative component shortening to explore theoretical chemical space
 - **Fingerprint Generation**: PFAS fingerprints for machine learning applications
+- **Group Feature Extraction**: Fixed-length named feature vectors for ML pipelines (see below)
 - **Visualization**: Assign and visualize PFAS groupings
 - **Multiple Interfaces**: Python API, command-line tool, and browser-based JavaScript version (RDKitJS)
 - **Batch Processing**: Efficient analysis of large chemical databases
 
+## Group Feature Extraction
+
+`extract_group_features` returns a structured `GroupFeatureResult` covering three
+chemically meaningful feature sets derived from the six component groups and the
+48 generic functional groups:
+
+```python
+from rdkit import Chem
+from PFASGroups import extract_group_features
+
+mol = Chem.MolFromSmiles("FC(F)(F)C(F)(F)C(F)(F)C(=O)O")  # PFOA-like
+r = extract_group_features(mol)
+
+# Polyhalogenated group match counts (groups 35/38/45, all halogens combined)
+print(r.poly_counts)
+# {'poly_alkyl': 1.0, 'poly_aryl': 0.0, 'poly_cyclic': 0.0}
+
+# Perhalogenated group max component sizes per halogen (groups 34/37/44 × F/Cl/Br/I/H)
+print(r.per_halogen_sizes['g34_F'])   # longest perfluoroalkyl chain (carbons)
+# 4.0
+
+# Alkyl chain size via H pseudo-halogen (convenience view of per_halogen_sizes H column)
+print(r.h_chain_sizes)  # octane: {'alkyl_H': 6.0, 'aryl_H': 0.0, 'cyclic_H': 0.0}
+
+# Generic functional groups (ids 29-76, wildcard)
+print({k: v for k, v in r.generic_groups.items() if v})
+# {'g42': 1.0, 'g48': 1.0}  →  carboxylic acid + fluoride
+
+# Fixed-length float32 array of shape (66,) for ML use
+arr = r.to_array()
+names = r.feature_names()  # matching labels
+```
+
+SMILES strings are accepted directly in addition to `rdkit.Chem.Mol` objects.
+See the [Group Feature Extraction](docs/group_features.rst) documentation page for
+the full feature layout, group ID table, and worked examples.
+
 ## Installation
 
 The recommended installation method is via pip.  RDKit must already be available in the target environment. It is recommended to use an environment manager (like Conda/Mamba, e.g [Miniforge](https://github.com/conda-forge/miniforge)) and install RDKit via 
@@ -454,7 +492,7 @@ h_group = HalogenGroup(
 )
 
 # Parse using H mode
-results = parse_smiles(smiles, halogens='H', pfas_groups=[h_group], bycomponent=True)
+results = parse_smiles(smiles, halogens='H', pfas_groups=[h_group])
 
 # Inspect H-component matches for the custom group
 h_matches = [m for m in results[0].matches if m.get('id') == 9990 and m.get('type') == 'HalogenGroup']
@@ -808,6 +846,9 @@ See [USER_GUIDE.md](USER_GUIDE.md) for comprehensive examples including:
 - Integration with pandas and scikit-learn
 
 ## Summary of changes by version
+- **Version 3.4.2**: Fixed ambiguity with OPPT 2023.
+
+- **Version 3.4.1**: Added generic embedding for non-halogenated specific compounds which includes wildcard-components functional groups and halogen component size. Fixed H components and added cyclic and aryl H components.
 
 - **Version 3.4.0**: Added H components (use in homologue series generation) and wildcard components to match generic functional groups (broader use than PFAS).
 

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/README.md

@@ -24,10 +24,48 @@ PFASGroups combines SMARTS pattern matching, molecular formula constraints, and
 ### Additional Tools
 - **Homologue Series Generation**: Iterative component shortening to explore theoretical chemical space
 - **Fingerprint Generation**: PFAS fingerprints for machine learning applications
+- **Group Feature Extraction**: Fixed-length named feature vectors for ML pipelines (see below)
 - **Visualization**: Assign and visualize PFAS groupings
 - **Multiple Interfaces**: Python API, command-line tool, and browser-based JavaScript version (RDKitJS)
 - **Batch Processing**: Efficient analysis of large chemical databases
 
+## Group Feature Extraction
+
+`extract_group_features` returns a structured `GroupFeatureResult` covering three
+chemically meaningful feature sets derived from the six component groups and the
+48 generic functional groups:
+
+```python
+from rdkit import Chem
+from PFASGroups import extract_group_features
+
+mol = Chem.MolFromSmiles("FC(F)(F)C(F)(F)C(F)(F)C(=O)O")  # PFOA-like
+r = extract_group_features(mol)
+
+# Polyhalogenated group match counts (groups 35/38/45, all halogens combined)
+print(r.poly_counts)
+# {'poly_alkyl': 1.0, 'poly_aryl': 0.0, 'poly_cyclic': 0.0}
+
+# Perhalogenated group max component sizes per halogen (groups 34/37/44 × F/Cl/Br/I/H)
+print(r.per_halogen_sizes['g34_F'])   # longest perfluoroalkyl chain (carbons)
+# 4.0
+
+# Alkyl chain size via H pseudo-halogen (convenience view of per_halogen_sizes H column)
+print(r.h_chain_sizes)  # octane: {'alkyl_H': 6.0, 'aryl_H': 0.0, 'cyclic_H': 0.0}
+
+# Generic functional groups (ids 29-76, wildcard)
+print({k: v for k, v in r.generic_groups.items() if v})
+# {'g42': 1.0, 'g48': 1.0}  →  carboxylic acid + fluoride
+
+# Fixed-length float32 array of shape (66,) for ML use
+arr = r.to_array()
+names = r.feature_names()  # matching labels
+```
+
+SMILES strings are accepted directly in addition to `rdkit.Chem.Mol` objects.
+See the [Group Feature Extraction](docs/group_features.rst) documentation page for
+the full feature layout, group ID table, and worked examples.
+
 ## Installation
 
 The recommended installation method is via pip.  RDKit must already be available in the target environment. It is recommended to use an environment manager (like Conda/Mamba, e.g [Miniforge](https://github.com/conda-forge/miniforge)) and install RDKit via 
@@ -406,7 +444,7 @@ h_group = HalogenGroup(
 )
 
 # Parse using H mode
-results = parse_smiles(smiles, halogens='H', pfas_groups=[h_group], bycomponent=True)
+results = parse_smiles(smiles, halogens='H', pfas_groups=[h_group])
 
 # Inspect H-component matches for the custom group
 h_matches = [m for m in results[0].matches if m.get('id') == 9990 and m.get('type') == 'HalogenGroup']
@@ -760,6 +798,9 @@ See [USER_GUIDE.md](USER_GUIDE.md) for comprehensive examples including:
 - Integration with pandas and scikit-learn
 
 ## Summary of changes by version
+- **Version 3.4.2**: Fixed ambiguity with OPPT 2023.
+
+- **Version 3.4.1**: Added generic embedding for non-halogenated specific compounds which includes wildcard-components functional groups and halogen component size. Fixed H components and added cyclic and aryl H components.
 
 - **Version 3.4.0**: Added H components (use in homologue series generation) and wildcard components to match generic functional groups (broader use than PFAS).
 

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/gui/data/help.html

@@ -3,7 +3,7 @@
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>PFASGroups GUI – Help</title>
+<title>PFASGroups GUI - Help</title>
 <style>
   :root {
     --orange:  #E15D0B;
@@ -83,25 +83,25 @@
 
   <h3>Data sources</h3>
   <ul>
-    <li><b>File</b> – CSV, Excel (.xlsx/.xls), or SQLite (.db/.sqlite).  Browse for the
+    <li><b>File</b> - CSV, Excel (.xlsx/.xls), or SQLite (.db/.sqlite).  Browse for the
         file, choose a sheet (Excel) and the SMILES / name columns.</li>
-    <li><b>Database</b> – SQLite, MariaDB, or PostgreSQL.  Fill in the connection form
+    <li><b>Database</b> - SQLite, MariaDB, or PostgreSQL.  Fill in the connection form
         (host, port, database name, user, password, table name).</li>
-    <li><b>Manual</b> – Paste SMILES directly.  One per line, or comma-separated with
+    <li><b>Manual</b> - Paste SMILES directly.  One per line, or comma-separated with
         optional names (<code>Name: SMILES</code>).</li>
   </ul>
 
   <h3>Options</h3>
   <ul>
-    <li><b>Halogens</b> – Which halogens to include in the analysis.  Start with
+    <li><b>Halogens</b> - Which halogens to include in the analysis.  Start with
         <code>F only</code> for classical PFAS; broaden to include Cl/Br/I for expanded
         screening.</li>
-    <li><b>Saturation filter</b> – <code>Perf. (CF₂/CF₃)</code> restricts to
+    <li><b>Saturation filter</b> - <code>Perf. (CF₂/CF₃)</code> restricts to
         perfluorinated chains; <code>All fluorinated</code> includes partially
         fluorinated structures.</li>
-    <li><b>Compute metrics</b> – Calculate graph-theoretic component metrics (needed
-        for Tabs 4–6).</li>
-    <li><b>Check definitions</b> – Additionally test each molecule against the PFAS
+    <li><b>Compute metrics</b> - Calculate graph-theoretic component metrics (needed
+        for Tabs 4-6).</li>
+    <li><b>Check definitions</b> - Additionally test each molecule against the PFAS
         definitions ticked below the option.</li>
   </ul>
 
@@ -123,9 +123,9 @@
 
   <h3>Controls</h3>
   <ul>
-    <li><b>Search</b> – filter cards by molecule name.</li>
-    <li><b>Show All / Hide All</b> – toggle structure visibility for all cards.</li>
-    <li><b>Export CSV</b> – save a summary table (name, SMILES, matched groups,
+    <li><b>Search</b> - filter cards by molecule name.</li>
+    <li><b>Show All / Hide All</b> - toggle structure visibility for all cards.</li>
+    <li><b>Export CSV</b> - save a summary table (name, SMILES, matched groups,
         definition results) to a CSV file.</li>
   </ul>
 </div>
@@ -133,24 +133,24 @@
 <!-- ────────────────────────────────────────────────────────────────── Tab 3 -->
 <h2><span class="step-num">3</span> Definition &amp; SMARTS Tester Tab</h2>
 <div class="card">
-  <h3>Sub-tab A – PFAS Definitions</h3>
+  <h3>Sub-tab A - PFAS Definitions</h3>
   <p>Enter a SMILES string and test it against:</p>
   <ul>
     <li><b>Built-in definitions</b> (default, when the custom JSON field is left blank).</li>
-    <li><b>Custom <code>PFASDefinition</code> JSON</b> – paste an array of definition
+    <li><b>Custom <code>PFASDefinition</code> JSON</b> - paste an array of definition
         objects.  Each must have <code>id</code>, <code>name</code>,
         <code>smarts</code> (list of SMARTS strings), and optionally
         <code>fluorineRatio</code> and <code>description</code>.</li>
   </ul>
 
-  <h3>Sub-tab B – Custom Group (SMARTS)</h3>
+  <h3>Sub-tab B - Custom Group (SMARTS)</h3>
   <p>Define a custom <code>HalogenGroup</code> and test a molecule against it.  Fields:</p>
   <ul>
-    <li><b>componentSmarts</b> – name of the underlying fluorine component pattern
+    <li><b>componentSmarts</b> - name of the underlying fluorine component pattern
         (e.g. <code>Perfluoroalkyl</code>).</li>
-    <li><b>SMARTS dict (JSON)</b> – mapping of SMARTS pattern → required minimum count,
+    <li><b>SMARTS dict (JSON)</b> - mapping of SMARTS pattern → required minimum count,
         e.g. <code>{"[CX3](=O)[OX2H1]": 1}</code>.</li>
-    <li><b>Constraints (JSON)</b> – element-count constraints,
+    <li><b>Constraints (JSON)</b> - element-count constraints,
         e.g. <code>{"gte": {"F": 4}}</code>.</li>
   </ul>
   <p>Diagnostics are printed as JSON in the right panel, showing which stage passed
@@ -166,11 +166,11 @@
 
   <h3>Modes</h3>
   <ul>
-    <li><b>Intrinsic: total component size</b> – sum of all matched fragment sizes.</li>
-    <li><b>Intrinsic: max component size</b> – largest single matched fragment.</li>
-    <li><b>Intrinsic: total + max</b> – weighted combination;
+    <li><b>Intrinsic: total component size</b> - sum of all matched fragment sizes.</li>
+    <li><b>Intrinsic: max component size</b> - largest single matched fragment.</li>
+    <li><b>Intrinsic: total + max</b> - weighted combination;
         use α and β to balance the two terms.</li>
-    <li><b>Reference-based KL divergence</b> – divergence from a supplied reference
+    <li><b>Reference-based KL divergence</b> - divergence from a supplied reference
         dataset.  Supply a CSV/Excel/SQLite file as the reference.</li>
   </ul>
 
@@ -188,10 +188,10 @@
 
   <h3>Methods</h3>
   <ul>
-    <li><b>UMAP</b> – fast, topology-preserving.  Adjust <em>n_neighbours</em>
+    <li><b>UMAP</b> - fast, topology-preserving.  Adjust <em>n_neighbours</em>
         (local structure) and <em>min_dist</em> (cluster compactness).</li>
-    <li><b>PCA</b> – linear; no hyper-parameters.</li>
-    <li><b>t-SNE</b> – non-linear; adjust <em>perplexity</em>.</li>
+    <li><b>PCA</b> - linear; no hyper-parameters.</li>
+    <li><b>t-SNE</b> - non-linear; adjust <em>perplexity</em>.</li>
   </ul>
 
   <h3>Fingerprint presets</h3>
@@ -218,13 +218,13 @@
 
   <h3>Fingerprint sets</h3>
   <ul>
-    <li><b>PFASGroups presets</b> – any combination of the benchmark-validated
+    <li><b>PFASGroups presets</b> - any combination of the benchmark-validated
         fingerprint presets (binary, best, best_2, …).</li>
-    <li><b>Morgan (RDKit)</b> – radius-2 Morgan fingerprint, 512 bits.  Useful
+    <li><b>Morgan (RDKit)</b> - radius-2 Morgan fingerprint, 512 bits.  Useful
         baseline.</li>
-    <li><b>ToxPrint (729 bits)</b> – requires pyCSRML to be installed.</li>
-    <li><b>TxP_PFAS (129 bits)</b> – PFAS-specific ToxPrint subset; requires pyCSRML.</li>
-    <li><b>Custom TSV/CSV</b> – rows = molecules (same order as input), columns = bits.
+    <li><b>ToxPrint (729 bits)</b> - requires pyCSRML to be installed.</li>
+    <li><b>TxP_PFAS (129 bits)</b> - PFAS-specific ToxPrint subset; requires pyCSRML.</li>
+    <li><b>Custom TSV/CSV</b> - rows = molecules (same order as input), columns = bits.
         No header row.</li>
   </ul>
 
@@ -232,9 +232,9 @@
   <p>All fingerprint-set pairs are compared using the Bayesian correlated t-test
   (Benavoli et al. 2017) with ROPE = 0.01 ROC-AUC.  The table reports:</p>
   <ul>
-    <li><b>P(A&gt;B)</b> – probability that set A is meaningfully better than B.</li>
-    <li><b>P(ROPE)</b> – probability that the two sets are practically equivalent.</li>
-    <li><b>P(B&gt;A)</b> – probability that set B is meaningfully better than A.</li>
+    <li><b>P(A&gt;B)</b> - probability that set A is meaningfully better than B.</li>
+    <li><b>P(ROPE)</b> - probability that the two sets are practically equivalent.</li>
+    <li><b>P(B&gt;A)</b> - probability that set B is meaningfully better than A.</li>
   </ul>
 
   <div class="note">
@@ -247,8 +247,8 @@
 <h2>Keyboard shortcuts</h2>
 <div class="card">
   <ul>
-    <li><code>Ctrl+Q</code> – quit the application.</li>
-    <li><code>Ctrl+W</code> – close (same as Ctrl+Q on Windows).</li>
+    <li><code>Ctrl+Q</code> - quit the application.</li>
+    <li><code>Ctrl+W</code> - close (same as Ctrl+Q on Windows).</li>
   </ul>
 </div>
 
@@ -266,9 +266,9 @@
 <div class="card">
   <ul>
     <li>Benavoli A et al. (2017) <em>Time for a Change: a Tutorial for Comparing
-        Multiple Classifiers Through Bayesian Analysis.</em> JMLR 18(1):2653–2688.</li>
+        Multiple Classifiers Through Bayesian Analysis.</em> JMLR 18(1):2653-2688.</li>
     <li>Nadeau C &amp; Bengio Y (2003) <em>Inference for the Generalization Error.</em>
-        Machine Learning 52(3):239–281.</li>
+        Machine Learning 52(3):239-281.</li>
   </ul>
 </div>
 

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PFASGroups"
-version = "3.4.0"
+version = "3.4.2"
 description = "A comprehensive cheminformatics package for automated detection, classification, and analysis of halogenated substances, with a focus on per- and polyfluoroalkyl substances (PFAS). Combines SMARTS pattern matching, molecular formula constraints, and graph-based pathfinding to identify 119 groups. Supports creations of embeddings with graph metrics for Machine Learning workflows."
 authors = [
     { name = "Luc T. Miaz", email = "luc@miaz.ch" }

{pfasgroups-3.4.0 → pfasgroups-3.4.2}/setup.cfg

@@ -1,12 +1,12 @@
 [metadata]
 name = PFASGroups
-version = 3.3.0
+version = 3.4.2
 description = A comprehensive cheminformatics package for automated detection, classification, and analysis of halogenated substances, with a focus on per- and polyfluoroalkyl substances (PFAS). Supports multi-halogen fingerprinting (F, Cl, Br, I) with per/poly saturation filtering and stackable fingerprint vectors.
 long_description = file: README.md
 long_description_content_type = text/markdown
 author = Luc T. Miaz
 author_email = luc@miaz.ch
-license = MIT
+license = CC-BY-NC-4.0
 
 [egg_info]
 tag_build =