overture-core 0.0.0__tar.gz

overture_core-0.0.0/.python-version

@@ -0,0 +1 @@
+3.11

overture_core-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Overture Maps
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

overture_core-0.0.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: overture-core
+Version: 0.0.0
+Summary: Shared Overture business logic — portable, framework-agnostic job classes.
+Author: Overture Maps Foundation
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/OvertureMaps/overture-core
+Project-URL: Source, https://github.com/OvertureMaps/overture-core/tree/main/packages/overture_core
+Project-URL: Issues, https://github.com/OvertureMaps/overture-core/issues
+Keywords: overture,overturemaps,stac,gis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: overture-serverless>=0.1.0
+Requires-Dist: overture-stac
+Requires-Dist: pystac>=1.8.4
+Requires-Dist: boto3>=1.35
+Provides-Extra: dev
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# overture_core
+
+[![PyPI](https://img.shields.io/pypi/v/overture-core.svg)](https://pypi.org/project/overture-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/overture-core.svg)](https://pypi.org/project/overture-core/)
+
+Shared, framework-agnostic business logic — portable job classes built on [`overture-serverless`](../overture_serverless).
+
+## Jobs
+
+- **`stac.job.PublishStac`** — publishes the Overture STAC catalog. Two modes selected by the presence of the `release` param:
+  - *single-release* (`release` + `source_path` + `scratch_bucket`): publish just that release, mirror scoped to `stac/{release}/`. Schema comes from the RC bundle's `metadata.json`.
+  - *walk* (no `release`, requires `scratch_bucket`): rebuild the catalog for every release currently in the public bucket, mirror the whole `stac/` prefix with delete-orphans. Schema per release comes from the existing STAC (`schema:version` in each `catalog.json`); on cache miss the job self-heals by reading schema from the released RC bundle in `scratch_bucket` and raises if it can't recover.
+
+## Future work
+
+- **Bundle-owned schema accessor** — when `ReleaseCandidateBundle` becomes publishable, move `read_schema_version_from_rc_bundle` onto it as `resolved_schema_version()`; single-release mode's schema read shrinks to one line.
+- **Upstream `build_release_catalog`** — file a PR against [OvertureMaps/stac](https://github.com/OvertureMaps/stac) exposing this as a public API (their CLI already does the exact call sequence). When it lands, our wrapper collapses.

overture_core-0.0.0/README.md

@@ -0,0 +1,17 @@
+# overture_core
+
+[![PyPI](https://img.shields.io/pypi/v/overture-core.svg)](https://pypi.org/project/overture-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/overture-core.svg)](https://pypi.org/project/overture-core/)
+
+Shared, framework-agnostic business logic — portable job classes built on [`overture-serverless`](../overture_serverless).
+
+## Jobs
+
+- **`stac.job.PublishStac`** — publishes the Overture STAC catalog. Two modes selected by the presence of the `release` param:
+  - *single-release* (`release` + `source_path` + `scratch_bucket`): publish just that release, mirror scoped to `stac/{release}/`. Schema comes from the RC bundle's `metadata.json`.
+  - *walk* (no `release`, requires `scratch_bucket`): rebuild the catalog for every release currently in the public bucket, mirror the whole `stac/` prefix with delete-orphans. Schema per release comes from the existing STAC (`schema:version` in each `catalog.json`); on cache miss the job self-heals by reading schema from the released RC bundle in `scratch_bucket` and raises if it can't recover.
+
+## Future work
+
+- **Bundle-owned schema accessor** — when `ReleaseCandidateBundle` becomes publishable, move `read_schema_version_from_rc_bundle` onto it as `resolved_schema_version()`; single-release mode's schema read shrinks to one line.
+- **Upstream `build_release_catalog`** — file a PR against [OvertureMaps/stac](https://github.com/OvertureMaps/stac) exposing this as a public API (their CLI already does the exact call sequence). When it lands, our wrapper collapses.

overture_core-0.0.0/overture_core/stac/job.py

@@ -0,0 +1,160 @@
+"""``PublishStac`` — composes ``publisher.py`` helpers into a serverless job.
+
+Two modes, selected by presence of the ``release`` parameter:
+
+- **single-release** (``release`` + ``source_path`` + ``scratch_bucket``
+  supplied): publish exactly that release. Schema resolved from the RC bundle
+  at ``source_path``. Mirror scoped to ``stac/{release}/`` only — no other
+  releases are touched.
+
+- **walk** (``scratch_bucket`` supplied, no ``release``): rebuild the catalog
+  for every release currently present in the public release bucket. Schema
+  per release comes from the existing STAC (``schema:version`` in each
+  release's ``catalog.json``); on cache miss the job **self-heals** by finding
+  the RC bundle with the ``released`` marker in ``scratch_bucket`` and
+  reading its ``metadata.json``. Self-heal is LOUD — it raises if it can't
+  recover the schema for a release, aborting the walk. Mirror covers the
+  whole ``stac/`` prefix with delete-orphans, so releases removed by bucket
+  lifecycle policy get their STAC items removed.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from overture_serverless.job import ServerlessPythonJob
+
+from overture_core.stac.publisher import (
+    PROD_ROOT_HREF,
+    PUBLIC_RELEASE_BUCKET,
+    STAC_S3_PREFIX,
+    build_release_catalog,
+    list_public_releases,
+    mirror_directory_to_s3,
+    read_existing_stac_schemas,
+    read_schema_from_released_rc,
+    read_schema_version_from_rc_bundle,
+)
+
+
+class PublishStac(ServerlessPythonJob):
+    def execute_job(self) -> None:
+        extras_bucket = self.get_param("extras_bucket")
+        root_href = self.get_param(
+            "root_href", default=PROD_ROOT_HREF, is_required=False
+        )
+        workers = int(self.get_param("workers", default=4, is_required=False))
+
+        release = self.get_param("release", is_required=False)
+
+        if release:
+            # single-release mode requires the coupled trio.
+            source_path = self.get_param("source_path", is_required=False)
+            scratch_bucket = self.get_param("scratch_bucket", is_required=False)
+            missing = [
+                name
+                for name, value in [
+                    ("source_path", source_path),
+                    ("scratch_bucket", scratch_bucket),
+                ]
+                if not value
+            ]
+            if missing:
+                raise ValueError(
+                    f"single-release mode requires release + source_path + scratch_bucket; "
+                    f"missing: {missing}"
+                )
+            self._publish_single(
+                release=release,
+                source_path=source_path,
+                scratch_bucket=scratch_bucket,
+                extras_bucket=extras_bucket,
+                root_href=root_href,
+                workers=workers,
+            )
+        else:
+            scratch_bucket = self.get_param("scratch_bucket")
+            release_bucket = self.get_param(
+                "release_bucket", default=PUBLIC_RELEASE_BUCKET, is_required=False
+            )
+            self._publish_walk(
+                scratch_bucket=scratch_bucket,
+                extras_bucket=extras_bucket,
+                release_bucket=release_bucket,
+                root_href=root_href,
+                workers=workers,
+            )
+
+    def _publish_single(
+        self,
+        release: str,
+        source_path: str,
+        scratch_bucket: str,
+        extras_bucket: str,
+        root_href: str,
+        workers: int,
+    ) -> None:
+        schema = read_schema_version_from_rc_bundle(scratch_bucket, source_path)
+        self.log(f"Publishing single release {release} with schema {schema}")
+
+        with tempfile.TemporaryDirectory() as tmp:
+            output = Path(tmp) / "stac"
+            output.mkdir(parents=True, exist_ok=True)
+            build_release_catalog(
+                release=release,
+                schema_version=schema,
+                output=output,
+                root_href=root_href,
+                workers=workers,
+            )
+            release_prefix = f"{STAC_S3_PREFIX}{release}/"
+            deleted = mirror_directory_to_s3(
+                output / release, extras_bucket, release_prefix
+            )
+            self.log(
+                f"Mirrored {release} to s3://{extras_bucket}/{release_prefix}; "
+                f"deleted {deleted} orphans within that release"
+            )
+
+    def _publish_walk(
+        self,
+        scratch_bucket: str,
+        extras_bucket: str,
+        release_bucket: str,
+        root_href: str,
+        workers: int,
+    ) -> None:
+        known_schemas = read_existing_stac_schemas(extras_bucket, STAC_S3_PREFIX)
+        self.log(f"Cached {len(known_schemas)} schemas from existing STAC")
+
+        releases = list_public_releases(release_bucket)
+        self.log(
+            f"Discovered {len(releases)} releases in s3://{release_bucket}/release/"
+        )
+
+        with tempfile.TemporaryDirectory() as tmp:
+            output = Path(tmp) / "stac"
+            output.mkdir(parents=True, exist_ok=True)
+            for release in releases:
+                schema = known_schemas.get(release)
+                if schema is None:
+                    self.log(
+                        f"No cached schema for {release}; self-healing from RC bundle in "
+                        f"s3://{scratch_bucket}"
+                    )
+                    schema = read_schema_from_released_rc(scratch_bucket, release)
+                    self.log(f"Self-healed {release} -> {schema}")
+                build_release_catalog(
+                    release=release,
+                    schema_version=schema,
+                    output=output,
+                    root_href=root_href,
+                    workers=workers,
+                )
+
+            deleted = mirror_directory_to_s3(output, extras_bucket, STAC_S3_PREFIX)
+            self.log(
+                f"Mirrored {len(releases)} releases to s3://{extras_bucket}/{STAC_S3_PREFIX}; "
+                f"deleted {deleted} orphans"
+            )

overture_core-0.0.0/overture_core/stac/publisher.py

@@ -0,0 +1,178 @@
+"""STAC publishing operations. Composed by ``job.py``."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import boto3
+import pystac
+from botocore import UNSIGNED
+from botocore.config import Config
+from overture_stac.overture_stac import OvertureRelease
+
+PROD_ROOT_HREF = "https://stac.overturemaps.org"
+STAC_S3_PREFIX = "stac/"
+PUBLIC_RELEASE_BUCKET = "overturemaps-us-west-2"
+
+
+def read_schema_version_from_rc_bundle(
+    scratch_bucket: str, input_source_path: str
+) -> str:
+    """Read ``schema_version`` from an RC bundle's ``metadata.json``."""
+    key = f"{input_source_path.rstrip('/')}/metadata.json"
+    obj = boto3.client("s3").get_object(Bucket=scratch_bucket, Key=key)
+    data: dict[str, Any] = json.loads(obj["Body"].read())
+    for inp in data.get("cdp_release_candidate_dag", {}).get("inputs", []):
+        for section_val in inp.values():
+            if isinstance(section_val, dict):
+                schema_version = section_val.get("parameters", {}).get("schema_version")
+                if schema_version:
+                    return schema_version
+    raise RuntimeError(f"schema_version not found in s3://{scratch_bucket}/{key}")
+
+
+def read_schema_from_released_rc(scratch_bucket: str, release: str) -> str:
+    """Find the RC bundle marked ``released`` for *release* and read its schema.
+
+    Walks ``release_candidate/release={release}/run=*/`` in *scratch_bucket*,
+    picks the run(s) carrying a ``released`` marker (the one that became a real
+    release), and returns its schema_version. Raises on any failure — used as a
+    LOUD self-heal fallback from walk mode.
+    """
+    import botocore.exceptions
+
+    s3 = boto3.client("s3")
+    prefix = f"release_candidate/release={release}/"
+
+    runs: list[str] = []
+    paginator = s3.get_paginator("list_objects_v2")
+    for page in paginator.paginate(Bucket=scratch_bucket, Prefix=prefix, Delimiter="/"):
+        for cp in page.get("CommonPrefixes", []):
+            run = cp["Prefix"][len(prefix) :].rstrip("/")
+            if run.startswith("run="):
+                runs.append(run)
+
+    if not runs:
+        raise RuntimeError(f"No RC runs found under s3://{scratch_bucket}/{prefix}")
+
+    released_runs: list[str] = []
+    for run in runs:
+        try:
+            s3.head_object(Bucket=scratch_bucket, Key=f"{prefix}{run}/released")
+            released_runs.append(run)
+        except botocore.exceptions.ClientError as exc:
+            if exc.response["Error"]["Code"] in ("404", "NoSuchKey"):
+                continue
+            raise
+
+    if not released_runs:
+        raise RuntimeError(
+            f"No RC run under s3://{scratch_bucket}/{prefix} has a 'released' marker"
+        )
+
+    chosen_run = sorted(released_runs)[-1]
+    return read_schema_version_from_rc_bundle(scratch_bucket, f"{prefix}{chosen_run}")
+
+
+def list_public_releases(
+    release_bucket: str = PUBLIC_RELEASE_BUCKET, prefix: str = "release/"
+) -> list[str]:
+    """List release versions currently present under ``s3://{release_bucket}/{prefix}``."""
+    s3 = boto3.client("s3", config=Config(signature_version=UNSIGNED))
+    releases: list[str] = []
+    paginator = s3.get_paginator("list_objects_v2")
+    for page in paginator.paginate(Bucket=release_bucket, Prefix=prefix, Delimiter="/"):
+        for cp in page.get("CommonPrefixes", []):
+            name = cp["Prefix"][len(prefix) :].rstrip("/")
+            if name:
+                releases.append(name)
+    return sorted(releases)
+
+
+def read_existing_stac_schemas(
+    extras_bucket: str, prefix: str = STAC_S3_PREFIX
+) -> dict[str, str]:
+    """Return ``{release: schema_version}`` extracted from any existing per-release
+    ``catalog.json`` at ``s3://{extras_bucket}/{prefix}<release>/catalog.json``.
+
+    Missing / unreadable / schema-less catalogs are silently skipped — this
+    map is a best-effort cache, not authoritative.
+    """
+    s3 = boto3.client("s3")
+    schemas: dict[str, str] = {}
+    paginator = s3.get_paginator("list_objects_v2")
+    for page in paginator.paginate(Bucket=extras_bucket, Prefix=prefix, Delimiter="/"):
+        for cp in page.get("CommonPrefixes", []):
+            release = cp["Prefix"][len(prefix) :].rstrip("/")
+            if not release:
+                continue
+            try:
+                obj = s3.get_object(
+                    Bucket=extras_bucket, Key=f"{prefix}{release}/catalog.json"
+                )
+                data = json.loads(obj["Body"].read())
+                schema = data.get("schema:version")
+                if schema:
+                    schemas[release] = schema
+            except Exception:
+                continue
+    return schemas
+
+
+def build_release_catalog(
+    release: str,
+    schema_version: str | None,
+    output: Path,
+    root_href: str = PROD_ROOT_HREF,
+    workers: int = 4,
+) -> None:
+    """Build one release's STAC catalog into *output*.
+
+    TODO: move upstream into ``overture-stac`` — this is the exact call
+    sequence in that library's CLI; belongs as a public API there.
+    """
+    catalog = OvertureRelease(
+        release=release,
+        schema=schema_version,
+        output=output,
+        debug=False,
+    )
+    catalog.build_release_catalog(
+        title=f"{release} Overture Release", max_workers=workers
+    )
+    catalog.release_catalog.normalize_hrefs(f"{root_href}/{release}/")
+    catalog.release_catalog.save(
+        catalog_type=pystac.CatalogType.ABSOLUTE_PUBLISHED,
+        dest_href=str(output / release),
+    )
+
+
+def mirror_directory_to_s3(local_root: Path, bucket: str, prefix: str) -> int:
+    """Mirror *local_root* to ``s3://{bucket}/{prefix}``; return orphan-delete count."""
+    s3 = boto3.client("s3")
+
+    local_keys: set[str] = set()
+    for path in local_root.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(local_root).as_posix()
+        key = f"{prefix}{rel}"
+        local_keys.add(key)
+        s3.upload_file(str(path), bucket, key)
+
+    remote_keys: set[str] = set()
+    paginator = s3.get_paginator("list_objects_v2")
+    for page in paginator.paginate(Bucket=bucket, Prefix=prefix):
+        for obj in page.get("Contents", []):
+            remote_keys.add(obj["Key"])
+
+    orphans = list(remote_keys - local_keys)
+    for i in range(0, len(orphans), 1000):
+        batch = orphans[i : i + 1000]
+        s3.delete_objects(
+            Bucket=bucket,
+            Delete={"Objects": [{"Key": k} for k in batch]},
+        )
+    return len(orphans)

overture_core-0.0.0/overture_core.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: overture-core
+Version: 0.0.0
+Summary: Shared Overture business logic — portable, framework-agnostic job classes.
+Author: Overture Maps Foundation
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/OvertureMaps/overture-core
+Project-URL: Source, https://github.com/OvertureMaps/overture-core/tree/main/packages/overture_core
+Project-URL: Issues, https://github.com/OvertureMaps/overture-core/issues
+Keywords: overture,overturemaps,stac,gis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: overture-serverless>=0.1.0
+Requires-Dist: overture-stac
+Requires-Dist: pystac>=1.8.4
+Requires-Dist: boto3>=1.35
+Provides-Extra: dev
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# overture_core
+
+[![PyPI](https://img.shields.io/pypi/v/overture-core.svg)](https://pypi.org/project/overture-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/overture-core.svg)](https://pypi.org/project/overture-core/)
+
+Shared, framework-agnostic business logic — portable job classes built on [`overture-serverless`](../overture_serverless).
+
+## Jobs
+
+- **`stac.job.PublishStac`** — publishes the Overture STAC catalog. Two modes selected by the presence of the `release` param:
+  - *single-release* (`release` + `source_path` + `scratch_bucket`): publish just that release, mirror scoped to `stac/{release}/`. Schema comes from the RC bundle's `metadata.json`.
+  - *walk* (no `release`, requires `scratch_bucket`): rebuild the catalog for every release currently in the public bucket, mirror the whole `stac/` prefix with delete-orphans. Schema per release comes from the existing STAC (`schema:version` in each `catalog.json`); on cache miss the job self-heals by reading schema from the released RC bundle in `scratch_bucket` and raises if it can't recover.
+
+## Future work
+
+- **Bundle-owned schema accessor** — when `ReleaseCandidateBundle` becomes publishable, move `read_schema_version_from_rc_bundle` onto it as `resolved_schema_version()`; single-release mode's schema read shrinks to one line.
+- **Upstream `build_release_catalog`** — file a PR against [OvertureMaps/stac](https://github.com/OvertureMaps/stac) exposing this as a public API (their CLI already does the exact call sequence). When it lands, our wrapper collapses.

overture_core-0.0.0/overture_core.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+.python-version
+LICENSE
+README.md
+pyproject.toml
+uv.lock
+overture_core/__init__.py
+overture_core.egg-info/PKG-INFO
+overture_core.egg-info/SOURCES.txt
+overture_core.egg-info/dependency_links.txt
+overture_core.egg-info/requires.txt
+overture_core.egg-info/scm_file_list.json
+overture_core.egg-info/scm_version.json
+overture_core.egg-info/top_level.txt
+overture_core/stac/__init__.py
+overture_core/stac/job.py
+overture_core/stac/publisher.py
+tests/__init__.py
+tests/stac/__init__.py
+tests/stac/test_job.py
+tests/stac/test_publisher.py

overture_core-0.0.0/overture_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

overture_core-0.0.0/overture_core.egg-info/requires.txt

@@ -0,0 +1,8 @@
+overture-serverless>=0.1.0
+overture-stac
+pystac>=1.8.4
+boto3>=1.35
+
+[dev]
+pytest>=9.1.1
+pytest-cov>=7.0.0

overture_core-0.0.0/overture_core.egg-info/scm_file_list.json

@@ -0,0 +1,17 @@
+{
+  "files": [
+    ".python-version",
+    "LICENSE",
+    "README.md",
+    "overture_core/__init__.py",
+    "overture_core/stac/__init__.py",
+    "overture_core/stac/job.py",
+    "overture_core/stac/publisher.py",
+    "pyproject.toml",
+    "tests/__init__.py",
+    "tests/stac/__init__.py",
+    "tests/stac/test_job.py",
+    "tests/stac/test_publisher.py",
+    "uv.lock"
+  ]
+}

overture_core-0.0.0/overture_core.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.0",
+  "distance": 0,
+  "node": "g96aaaef",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-08-25"
+}

overture_core-0.0.0/overture_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+overture_core

overture_core-0.0.0/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "overture-core"
+dynamic = ["version"]
+description = "Shared Overture business logic — portable, framework-agnostic job classes."
+authors = [
+    {name = "Overture Maps Foundation"}
+]
+license = "MIT"
+# Vendored copy of the repo-root LICENSE: setuptools copies license-files
+# sdist entries to the exact relative path given, so "../../LICENSE" landed
+# outside the sdist root and PyPI rejected the upload. A package-local path
+# is the only one that survives packaging.
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["overture", "overturemaps", "stac", "gis"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "overture-serverless>=0.1.0",
+    "overture-stac",
+    "pystac>=1.8.4",
+    "boto3>=1.35",
+]
+
+[project.urls]
+Homepage = "https://github.com/OvertureMaps/overture-core"
+Source = "https://github.com/OvertureMaps/overture-core/tree/main/packages/overture_core"
+Issues = "https://github.com/OvertureMaps/overture-core/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-cov>=7.0.0",
+]
+
+[build-system]
+requires = ["setuptools>=77.0.3", "setuptools_scm>=8.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["overture_core*"]
+
+[tool.setuptools_scm]
+root = "../.."
+tag_regex = "^overture_core-v(?P<version>.*)$"
+git_describe_command = "git describe --dirty --tags --long --match 'overture_core-v*'"
+# PyPI (and Test PyPI) rejects local version identifiers (the "+g<hash>"
+# suffix setuptools_scm appends between tags), so drop it. Only affects
+# unreleased/dirty builds (e.g. the workflow_dispatch smoke test) — a real
+# release always builds from a clean tag.
+local_scheme = "no-local-version"
+
+[tool.uv.sources]
+overture-serverless = { path = "../overture_serverless" }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["overture_core"]
+
+[tool.coverage.report]
+fail_under = 95
+show_missing = true
+
+[tool.semantic_release]
+commit_parser = "conventional-monorepo"
+tag_format = "overture_core-v{version}"
+allow_zero_version = true
+
+# path_filters (relative to this directory, since the release workflow cds
+# here) is what attributes a commit to this package: PSR checks the commit's
+# actual changed files, not its scope. No scope_prefix is set, so a plain
+# `fix: ...`/`feat: ...` with no scope works, as long as the commit touches
+# files under packages/overture_core/.
+[tool.semantic_release.commit_parser_options]
+path_filters = ["."]

overture_core-0.0.0/setup.cfg

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