edges 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

edges/flow_matching.py

@@ -2,15 +2,16 @@ from collections import defaultdict
 from functools import lru_cache
 import numpy as np
 from copy import deepcopy
-import json
+import json, time
 from typing import NamedTuple, List, Optional
 
-from .utils import make_hashable
+from .utils import make_hashable, _short_cf, _head
 
 
 import logging
 
 logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
 
 
 def preprocess_cfs(cf_list, by="consumer"):
@@ -99,11 +100,13 @@ def process_cf_list(
             best_cf = cf
 
     if best_cf:
-        logger.debug(f"Best matching CF selected with score {best_score}: {best_cf}")
+        logger.debug("Best matching CF selected with score %d: %s", best_score, best_cf)
         results.append(best_cf)
     else:
         logger.debug(
-            f"No matching CF found for supplier {filtered_supplier} and consumer {filtered_consumer}."
+            "No matching CF found for supplier %s and consumer %s.",
+            filtered_supplier,
+            filtered_consumer,
         )
 
     return results
@@ -577,116 +580,161 @@ def compute_average_cf(
     required_consumer_fields: set = None,
 ) -> tuple[str | float, Optional[dict], Optional[dict]]:
     """
-    Compute weighted CF and a **canonical** aggregated uncertainty for composite regions.
-    No sampling is performed here.
-    Returns:
-        expr_or_value: str | float
-        matched_cf_obj: Optional[dict]   # present only when exactly 1 CF matched
-        agg_uncertainty: Optional[dict]  # discrete_empirical mixture if >1 CF
+    Compute weighted CF and a canonical aggregated uncertainty for composite regions.
+    Returns: (expr_or_value, matched_cf_obj|None, agg_uncertainty|None)
     """
+    # Optional timing (only if DEBUG)
+    _t0 = time.perf_counter() if logger.isEnabledFor(logging.DEBUG) else None
+
     if not candidate_suppliers and not candidate_consumers:
-        logger.debug("No candidate suppliers or consumers provided.")
+        logger.warning(
+            "CF-AVG: no candidate locations provided | supplier_cands=%s | consumer_cands=%s",
+            candidate_suppliers,
+            candidate_consumers,
+        )
         return 0, None, None
 
+    # -------- Gate 1: location-key presence in cf_index --------
     valid_location_pairs = [
         (s, c)
         for s in candidate_suppliers
         for c in candidate_consumers
         if cf_index.get((s, c))
     ]
+
     if not valid_location_pairs:
-        logger.debug(
-            f"No valid location pairs found for suppliers {candidate_suppliers} "
-            f"and consumers {candidate_consumers}."
-        )
+        if logger.isEnabledFor(logging.DEBUG):
+            # show small sample of what keys do exist for quick diagnosis
+            some_keys = _head(cf_index.keys(), 10)
+            logger.debug(
+                "CF-AVG: no (supplier,consumer) keys in cf_index for candidates "
+                "| suppliers=%s | consumers=%s | sample_index_keys=%s",
+                _head(candidate_suppliers),
+                _head(candidate_consumers),
+                some_keys,
+            )
         return 0, None, None
+    else:
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "CF-AVG: %d valid (s,c) keys found (showing up to 10): %s",
+                len(valid_location_pairs),
+                _head(valid_location_pairs, 10),
+            )
 
+    # Build field-filtered views (exclude location; added per-loop)
     filtered_supplier = {
         k: supplier_info[k]
-        for k in required_supplier_fields
+        for k in (required_supplier_fields or ())
         if k in supplier_info and k != "location"
     }
     filtered_consumer = {
         k: consumer_info[k]
-        for k in required_consumer_fields
+        for k in (required_consumer_fields or ())
         if k in consumer_info and k != "location"
     }
 
+    # -------- Gate 2: field/operator/classification match --------
     matched = []
+    total_candidates_seen = 0
+
     for s_loc, c_loc in valid_location_pairs:
-        cands = cf_index.get((s_loc, c_loc))
-        if not cands:
-            continue
+        cands = cf_index.get((s_loc, c_loc)) or []
+        total_candidates_seen += len(cands)
+
         filtered_supplier["location"] = s_loc
         filtered_consumer["location"] = c_loc
-        matched.extend(process_cf_list(cands, filtered_supplier, filtered_consumer))
+
+        got = process_cf_list(cands, filtered_supplier, filtered_consumer)
+        if logger.isEnabledFor(logging.DEBUG) and got:
+            logger.debug(
+                "CF-AVG: matched %d/%d CFs @ (%s,%s); example=%s",
+                len(got),
+                len(cands),
+                s_loc,
+                c_loc,
+                _short_cf(got[0]),
+            )
+        matched.extend(got)
 
     if not matched:
-        logger.debug(
-            f"No matched CFs for supplier {supplier_info} and consumer {consumer_info} "
-            f"with location pairs {valid_location_pairs}."
-        )
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "CF-AVG: 0 CFs matched after field/classification checks "
+                "| supplier_info=%s | consumer_info=%s | pairs=%s | total_candidates_seen=%d",
+                supplier_info,
+                consumer_info,
+                _head(valid_location_pairs, 10),
+                total_candidates_seen,
+            )
         return 0, None, None
 
+    # Weights
     total_w = sum(cf.get("weight", 0.0) for cf in matched)
     if total_w == 0:
         logger.warning(
-            f"No valid weights found for supplier {supplier_info} and consumer {consumer_info}. "
-            "Using equal shares."
+            "CF-AVG: weights all zero/missing → using equal shares | matched=%d | example=%s",
+            len(matched),
+            _short_cf(matched[0]) if matched else None,
         )
         matched_cfs = [(cf, 1.0 / len(matched)) for cf in matched]
     else:
         matched_cfs = [(cf, cf.get("weight", 0.0) / total_w) for cf in matched]
 
-    assert np.isclose(
-        sum(s for _, s in matched_cfs), 1.0
-    ), f"Total shares must equal 1. Got: {sum(s for _, s in matched_cfs)}"
+    # Safety check on weights; log before assert explodes
+    share_sum = sum(s for _, s in matched_cfs)
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(
+            "CF-AVG: matched=%d | sum_shares=%.6f | example=%s",
+            len(matched_cfs),
+            share_sum,
+            _short_cf(matched_cfs[0][0]) if matched_cfs else None,
+        )
+
+    assert np.isclose(share_sum, 1.0), f"Total shares must equal 1. Got: {share_sum}"
 
-    # Weighted expression for deterministic path
+    # Build deterministic expression (string)
     expressions = [f"({share:.3f} * ({cf['value']}))" for cf, share in matched_cfs]
     expr = " + ".join(expressions)
 
-    # === NEW: aggregated uncertainty as a hierarchical mixture (no sampling) ===
-    # If only one CF: pass through its uncertainty directly
+    # Single CF shortcut (pass-through uncertainty)
     if len(matched_cfs) == 1:
         single_cf = matched_cfs[0][0]
         agg_uncertainty = single_cf.get("uncertainty")
+        if logger.isEnabledFor(logging.DEBUG):
+            dt = (time.perf_counter() - _t0) if _t0 else None
+            logger.debug(
+                "CF-AVG: single CF path | expr=%s | has_unc=%s | dt=%.3f ms",
+                expr,
+                bool(agg_uncertainty),
+                (dt * 1000.0) if dt else -1.0,
+            )
         return (expr, single_cf, agg_uncertainty)
 
+    # Multi-CF aggregated uncertainty
     def _cf_sign(cf_obj) -> int | None:
-        """Infer sign from uncertainty.negative if present, else from numeric value."""
         neg = (cf_obj.get("uncertainty") or {}).get("negative", None)
         if neg in (0, 1):
             return -1 if neg == 1 else +1
         v = cf_obj.get("value")
         if isinstance(v, (int, float)):
-            if v < 0:
-                return -1
-            if v > 0:
-                return +1
-        return None  # unknown (e.g., string expr)
+            return -1 if v < 0 else (+1 if v > 0 else None)
+        return None
 
-    # Try to determine a single aggregate sign across constituents
     cf_signs = [s for (cf, _sh) in matched_cfs if (s := _cf_sign(cf)) is not None]
     agg_sign = (
         cf_signs[0] if (cf_signs and all(s == cf_signs[0] for s in cf_signs)) else None
     )
 
-    # Build child magnitude distributions (no sampling)
-    child_values = []
-    child_weights = []
-
+    child_values, child_weights = [], []
     for cf, share in matched_cfs:
         if share <= 0:
             continue
-
         if cf.get("uncertainty") is not None:
-            # Copy child's uncertainty and strip sign to make it magnitude-only
             u = deepcopy(cf["uncertainty"])
             u["negative"] = 0
             child_unc = u
         else:
-            # Deterministic child → wrap as a 1-point discrete over |value|
             v = cf.get("value")
             if isinstance(v, (int, float)):
                 child_unc = {
@@ -695,43 +743,49 @@ def compute_average_cf(
                     "negative": 0,
                 }
             else:
-                # We can’t build a magnitude distribution from a symbolic string deterministically.
-                # Be conservative: skip aggregated-uncertainty so MC still works (deterministic anyway).
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(
+                        "CF-AVG: skip agg-unc (symbolic child without unc) | child=%s",
+                        _short_cf(cf),
+                    )
                 return (expr, None, None)
-
         child_values.append(child_unc)
         child_weights.append(float(share))
 
-    # Normalize weights and optionally canonicalize order for stable keys
     wsum = sum(child_weights) or 1.0
     child_weights = [w / wsum for w in child_weights]
 
-    # (Optional but helpful) canonicalize order by serialized child value to stabilize cache keys
     ordering = sorted(
         range(len(child_values)),
         key=lambda i: json.dumps(child_values[i], sort_keys=True),
     )
     child_values = [child_values[i] for i in ordering]
     child_weights = [child_weights[i] for i in ordering]
-    # remove values and weights where weights == 0
+
     filtered = [
         (v, w) for v, w in zip(child_values, child_weights) if w > 0 and v is not None
     ]
     if not filtered:
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("CF-AVG: filtered children empty after cleanup.")
         return 0, None, None
     child_values, child_weights = zip(*filtered)
 
     agg_uncertainty = {
         "distribution": "discrete_empirical",
-        "parameters": {
-            "values": child_values,  # each is a distribution dict (magnitude-only)
-            "weights": child_weights,  # shares
-        },
-        # IMPORTANT: the sign is carried only at the top level so uptake/release share the same cache key
-        # make_distribution_key() already ignores "negative"
+        "parameters": {"values": list(child_values), "weights": list(child_weights)},
     }
     if agg_sign is not None:
         agg_uncertainty["negative"] = 1 if agg_sign == -1 else 0
 
-    # Multi-CF mixture → no single "matched_cf_obj"
+    if logger.isEnabledFor(logging.DEBUG):
+        dt = (time.perf_counter() - _t0) if _t0 else None
+        logger.debug(
+            "CF-AVG: success | children=%d | expr_len=%d | agg_sign=%s | dt=%.3f ms",
+            len(child_values),
+            len(expr),
+            agg_sign,
+            (dt * 1000.0) if dt else -1.0,
+        )
+
     return (expr, None, agg_uncertainty)

edges/georesolver.py

@@ -5,23 +5,15 @@ import logging
 from constructive_geometries import Geomatcher
 from .utils import load_missing_geographies, get_str
 
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
 
 class GeoResolver:
     def __init__(self, weights: dict):
         self.weights = {get_str(k): v for k, v in weights.items()}
         self.weights_key = ",".join(sorted(self.weights.keys()))
-        self.logger = logging.getLogger("GeoResolver")
-        self.logger.setLevel(logging.DEBUG)
-
-        if not self.logger.handlers:
-            fh = logging.FileHandler("georesolver.log")
-            formatter = logging.Formatter(
-                "%(asctime)s %(name)s %(levelname)s: %(message)s", datefmt="%H:%M:%S"
-            )
-            fh.setFormatter(formatter)
-            fh.setLevel(logging.DEBUG)
-            self.logger.addHandler(fh)
-            self.logger.propagate = False
+        self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
 
         # Dependencies from constructive_geometries and your utils
         self.geo = Geomatcher()
@@ -69,7 +61,7 @@ class GeoResolver:
                         if not containing:
                             break
             except KeyError:
-                self.logger.info(f"Region: {location}. No geometry found.")
+                self.logger.info("Region %s: no geometry found.", location)
 
         return results
 

edges/logging_config.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+import logging
+import logging.config
+
+
+def setup_package_logging(
+    log_path: Path = Path("edges.log"), level: int = logging.INFO
+) -> None:
+    """
+    Route all logs from the 'edges' package (and submodules) into one file.
+    """
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "standard": {
+                    "format": "%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+                    "datefmt": "%Y-%m-%d %H:%M:%S",
+                }
+            },
+            "handlers": {
+                "edges_file": {
+                    "class": "logging.FileHandler",
+                    "filename": str(log_path),
+                    "mode": "w",
+                    "encoding": "utf-8",
+                    "formatter": "standard",
+                    "level": level,
+                }
+            },
+            "loggers": {
+                "edges": {
+                    "handlers": ["edges_file"],
+                    "level": level,
+                    "propagate": False,
+                }
+            },
+            "root": {"level": "WARNING", "handlers": []},
+        }
+    )

edges/uncertainty.py

@@ -7,13 +7,20 @@ import json
 from copy import deepcopy
 from scipy import stats
 import hashlib
+import logging
 
 from edges.utils import safe_eval
 
 
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
 def get_rng_for_key(key: str, base_seed: int) -> np.random.Generator:
     key_digest = int(hashlib.sha256(key.encode()).hexdigest(), 16) % (2**32)
-    return np.random.default_rng(base_seed + key_digest)
+    seed = base_seed + key_digest
+    logger.debug("Creating RNG with derived seed %d for key %s", seed, key)
+    return np.random.default_rng(seed)
 
 
 def make_distribution_key(cf):
@@ -25,6 +32,7 @@ def make_distribution_key(cf):
         return json.dumps(unc_copy, sort_keys=True)
     else:
         # No uncertainty block → return None = skip caching
+        logger.debug("No uncertainty block present; skipping cache key.")
         return None
 
 
@@ -107,7 +115,13 @@ def sample_cf_distribution(
         if dist_name == "discrete_empirical":
             values = params["values"]
             weights = np.array(params["weights"])
-            weights = weights / weights.sum() if weights.sum() != 0 else weights
+            if weights.sum() == 0:
+                logger.warning(
+                    "All weights are zero in discrete_empirical; using equal weights."
+                )
+                weights = np.ones_like(weights, dtype=float) / len(weights)
+            else:
+                weights = weights / weights.sum()
 
             chosen_indices = random_state.choice(len(values), size=n, p=weights)
 
@@ -184,9 +198,15 @@ def sample_cf_distribution(
             samples = np.clip(samples, params["minimum"], params["maximum"])
 
         else:
+            logger.warning(
+                "Unknown distribution '%s'; falling back to constant value.", dist_name
+            )
             samples = np.full(n, cf["value"], dtype=float)
 
     except ValueError as e:
+        logger.error(
+            "Error sampling distribution '%s' with parameters %s", dist_name, params
+        )
         raise ValueError(
             f"Error sampling distribution '{dist_name}' with parameters {params}: {e}"
         )

edges/utils.py

@@ -35,6 +35,7 @@ from .filesystem_constants import DATA_DIR
 
 
 logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
 
 _eval_cache = {}
 
@@ -130,23 +131,41 @@ def add_population_and_gdp_data(data: list, weight: str) -> list:
     # load population data from data/population.yaml
 
     if weight == "population":
-        with open(
-            DATA_DIR / "metadata" / "population.yaml", "r", encoding="utf-8"
-        ) as f:
-            weighting_data = yaml.safe_load(f)
+        path = DATA_DIR / "metadata" / "population.yaml"
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                weighting_data = yaml.safe_load(f)
+        except FileNotFoundError:
+            logger.error("Population metadata file not found at %s", path)
+            raise
 
     # load GDP data from data/gdp.yaml
     if weight == "gdp":
-        with open(DATA_DIR / "metadata" / "gdp.yaml", "r", encoding="utf-8") as f:
-            weighting_data = yaml.safe_load(f)
+        path = DATA_DIR / "metadata" / "gdp.yaml"
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                weighting_data = yaml.safe_load(f)
+        except FileNotFoundError:
+            logger.error("GDP metadata file not found at %s", path)
+            raise
 
     # add to the data dictionary
+    missing = 0
     for cf in data:
         for category in ["consumer", "supplier"]:
             if "location" in cf[category]:
                 if "weight" not in cf:
                     k = cf[category]["location"]
-                    cf["weight"] = weighting_data.get(k, 0)
+                    w = weighting_data.get(k, 0)
+                    if not w:
+                        missing += 1
+                    cf["weight"] = w
+    if missing:
+        logger.warning(
+            "Added weights with %d missing entries (defaulted to 0) for weight='%s'",
+            missing,
+            weight,
+        )
 
     return data
 
@@ -207,6 +226,7 @@ def get_flow_matrix_positions(mapping: dict) -> list:
     # Batch retrieve flows using get_activities() (assumed available in bw2data)
     keys = list(mapping.keys())
     flows_objs = get_activities(keys)
+    logger.debug("Resolved %d flow objects for %d keys", len(flows_objs), len(keys))
 
     # Build a lookup mapping both the numeric ID (if available) and (database, code)
     # tuple to the original flow object.
@@ -229,6 +249,7 @@ def get_flow_matrix_positions(mapping: dict) -> list:
                     flow = f
                     break
         if flow is None:
+            logger.error("Flow with key %s not found in fetched objects", k)
             raise KeyError(f"Flow with key {k} not found.")
         data = normalize_flow(flow)
         result.append(
@@ -304,6 +325,12 @@ def get_activities(keys, **kwargs):
             nodes.append(obj)
 
     if len(nodes) != len(keys):
+        logger.error(
+            "Requested %d activities but found %d. Keys (sample): %s",
+            len(keys),
+            len(nodes),
+            keys[:5],
+        )
         raise Exception("Not all requested activity objects were found.")
 
     return nodes
@@ -412,3 +439,26 @@ def assert_no_nans_in_cf_list(cf_list: list[dict], file_source: str = "<input>")
                         f"NaN detected in {side} field '{k}' of CF at index {i} "
                         f"in {file_source}: {entry}. This field must be removed or filled."
                     )
+
+
+def _head(seq, n=8):
+    try:
+        seq = list(seq)
+        return seq[:n] + (["…"] if len(seq) > n else [])
+    except Exception:
+        return seq
+
+
+def _short_cf(cf: dict, maxlen=160):
+    """Compact view of a CF for logs."""
+    try:
+        core = {
+            "value": cf.get("value"),
+            "weight": cf.get("weight"),
+            "supplier_loc": cf.get("supplier", {}).get("location"),
+            "consumer_loc": cf.get("consumer", {}).get("location"),
+        }
+        s = json.dumps(core, sort_keys=True)
+        return (s[: maxlen - 1] + "…") if len(s) > maxlen else s
+    except Exception:
+        return str(cf)[:maxlen]

{edges-1.0.0.dist-info → edges-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edges
-Version: 1.0.0
+Version: 1.0.2
 Summary: Country-specific characterization factors for the Brightway LCA framework
 Author-email: Romain Sacchi <romain.sacchi@psi.ch>, Alvaro Hahn Menacho <alvaro.hahn-menacho@psi.ch>
 Maintainer-email: Romain Sacchi <romain.sacchi@psi.ch>

{edges-1.0.0.dist-info → edges-1.0.2.dist-info}/RECORD

@@ -1,17 +1,19 @@
-edges/__init__.py,sha256=ngeGJD83FAbjQZE0h4G30BSt0rlGEWW3J4sVBgODAoo,348
+edges/__init__.py,sha256=TqfojQSsRPk1P355Hwv7vXTnJ4UkUXmp1tL8pk-_094,398
 edges/analysis.py,sha256=FkJzqFkormYOzhEP5p7YGsmxwN66JdMfktokGRUKjKI,7388
 edges/costs.py,sha256=OV46FS627fw6BikbRvtWWdXRvt4oRl8zsA9-Z8bdOkU,23399
-edges/edgelcia.py,sha256=y0oaMQEQ9P49-mfL5gjgvgkVsrbJHM_Rwt2qYDkBjBg,102259
+edges/edgelcia.py,sha256=qQO1fAbZwBQ52rZ1h2212OfZMKdWuIsLjMxmqPbk2v4,109472
 edges/filesystem_constants.py,sha256=FSH8hW84V1MCMvo8UOeZKM5Up26ls6bLbTRvfMl2tAg,207
-edges/flow_matching.py,sha256=yhpE0lmrZBv_FJS9SFc2qiuNU6PJs9TdYnAAxdvP70E,25122
-edges/georesolver.py,sha256=07a4e8heYG-wyUIWbFZ9VU6DsI9JrBIwa7aPF2-1-MA,3663
+edges/flow_matching.py,sha256=ElG7S6-MUM52fcNgbVarpOu5JlF1lLRu_7FRVIniOdk,26841
+edges/georesolver.py,sha256=a_RDfd0hXgrJAlqui4aLU8RrNLd0HUw3fxyc2TzaM1c,3328
+edges/logging_config.py,sha256=zZLxKsh7on0v9HaGBp45ynqTrEuDa3wPgMvTognoum0,1231
 edges/matrix_builders.py,sha256=vXl80pKfIeXWkYkTJsD4c8aVrFexWncqwl1saA0gRCM,1800
-edges/uncertainty.py,sha256=VyVtqR5VCi5awHzK9dLEXM4n7NQFszSt_1axn0D60Gw,6938
-edges/utils.py,sha256=1anorkm36qA7UZGRwKG7_28MAkobZpvj-VWon04prg4,13248
+edges/uncertainty.py,sha256=BfeFFv-qiTYerfKZ2qmql_Y5ps_0-lTqiLdeh9ixMQE,7681
+edges/utils.py,sha256=boVrCOeq4RZjbQ8u-xPMPdiE3uYwXBVfLqRO6NuYkBI,14868
 edges/data/AWARE 2.0_Country_all_yearly.json,sha256=n84gbYCsF5USg4NHePhSvlVdv0geTgtd-epfCu_Yo48,13187497
 edges/data/AWARE 2.0_Country_irri_yearly.json,sha256=Dz3uV2_6sHXeZWYEfwDTDXa2IDd8LhQKXtK2_HW5iME,3068174
 edges/data/AWARE 2.0_Country_non_irri_yearly.json,sha256=ORrik2I8cADIDbLq22o6UXxETSTVYCxwM-zn9q9OcDE,4502866
 edges/data/AWARE 2.0_Country_unspecified_yearly.json,sha256=ZqfBd3A3nMMcxSXMxBQ-FMwdwGcIf26GDOZPJZZXjzs,3806191
+edges/data/GeoPolRisk_elementary flows_2024.json,sha256=vC8qdxDXzX7OZQZZvQ3YMJRYTztsXk9bo9rXbRiyuok,18249
 edges/data/GeoPolRisk_paired_2024.json,sha256=epYBpA-uYtjf1Fb5z5rnvjjyTYsc2FzOkt8rQA2oB1k,21542889
 edges/data/ImpactWorld+ 2.1_Freshwater acidification_damage.json,sha256=ICpDkcn0VFD86hRdFxQWotIHvXI96ayzB6EMdTthvAY,7347463
 edges/data/ImpactWorld+ 2.1_Freshwater acidification_midpoint.json,sha256=ecx4eLu88mmT5XlqbVeC-xeWpiyEJJ3vRy31_oCBr9E,7362861
@@ -63,7 +65,7 @@ edges/data/SCP_1.0.json,sha256=s0bRZ-IVfUTMnm3F2yMsT-lDSaww1sMviQIOE7xMNJA,60068
 edges/data/metadata/gdp.yaml,sha256=_I13ZlffUigydP74iGA6eTTNmZdup70KP1GiFQkxRDQ,5509
 edges/data/metadata/missing_geographies.yaml,sha256=eTzO-I642ecG49_nn03fGPgWl-60VCYstWLjGk4h0i8,33
 edges/data/metadata/population.yaml,sha256=BnNaYnx2SrfJLf1lf1-fKfG9JIilC95StgJiCu2so3I,4769
-edges-1.0.0.dist-info/METADATA,sha256=Ab50iDqNUtJlJrrND0oFnBo5c_jkm9cfrLbZcdBpibQ,9974
-edges-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-edges-1.0.0.dist-info/top_level.txt,sha256=85BmdR7cFR5dfKfZ4mdJ4omGk9t4C89GE6N0RS3CCGA,6
-edges-1.0.0.dist-info/RECORD,,
+edges-1.0.2.dist-info/METADATA,sha256=5J6EYmBCgZLCKfxqDl7qUkco5FIJvsw-xP0tcGv3ifQ,9974
+edges-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+edges-1.0.2.dist-info/top_level.txt,sha256=85BmdR7cFR5dfKfZ4mdJ4omGk9t4C89GE6N0RS3CCGA,6
+edges-1.0.2.dist-info/RECORD,,