httk-core 2.1.0__tar.gz → 2.1.1__tar.gz

{httk_core-2.1.0 → httk_core-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httk-core
-Version: 2.1.0
+Version: 2.1.1
 Summary: httk₂ core functionality
 Author-email: Rickard Armiento <rickard-gpg@armiento.net>
 License-Expression: AGPL-3.0-or-later

{httk_core-2.1.0 → httk_core-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "httk-core"
-version = "2.1.0"
+version = "2.1.1"
 description = "httk₂ core functionality"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk/core/datastream/network_policy.py

@@ -1,6 +1,6 @@
 """Policy and timeout helpers for network-backed datastream opens."""
 
-DEFAULT_NETWORK_TIMEOUT: float | None = 30.0
+DEFAULT_NETWORK_TIMEOUT: float | None = 120.0
 """Default timeout for each network open; read freshly for every open, or ``None`` to disable."""
 
 NETWORK_SCHEMES = frozenset({"http", "https", "ftp"})

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk/core/optimade/__init__.py

@@ -11,6 +11,7 @@ from .entries import (
     OptimadeReference,
     ReferenceView,
     decode_optimade_value,
+    decode_optional_timestamp,
 )
 from .filter import FilterAst, ParserError, ParserSyntaxError, parse_optimade_filter, parse_optimade_filter_raw
 from .resources import (
@@ -24,8 +25,16 @@ from .resources import (
     redact_optimade_document_text,
     redact_optimade_url,
 )
+from .standard_names import (
+    STANDARD_NAME_EVIDENCE,
+    StandardSchemaCompletion,
+    complete_standard_schema,
+    infer_standard_names,
+    parse_optimade_api_version,
+)
 
 __all__ = [
+    "STANDARD_NAME_EVIDENCE",
     "CalculationView",
     "FileView",
     "FilterAst",
@@ -41,11 +50,16 @@ __all__ = [
     "ParserError",
     "ParserSyntaxError",
     "ReferenceView",
+    "StandardSchemaCompletion",
+    "complete_standard_schema",
     "decode_optimade_value",
+    "decode_optional_timestamp",
+    "infer_standard_names",
     "is_optimade_entry_url",
     "optimade_document_root",
     "optimade_entry_url_info",
     "optimade_resource_from_url",
+    "parse_optimade_api_version",
     "parse_optimade_filter",
     "parse_optimade_filter_raw",
     "redact_optimade_document_text",

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk/core/optimade/entries.py

@@ -9,6 +9,8 @@ delegated field) is requested.
 """
 
 import datetime
+import logging
+import re
 from collections.abc import Callable, Mapping
 from dataclasses import MISSING, dataclass, field, fields
 from decimal import Decimal
@@ -120,6 +122,66 @@ def decode_optimade_value(definition: PropertyDefinition, value: object) -> obje
     return _decode_by_payload(cast(Mapping[str, object], definition.as_optimade()), value)
 
 
+# Service origins already reported for serving an offset-less optional timestamp.
+# Bounded by the number of distinct service origins encountered in a process.
+_naive_timestamp_origins_warned: set[str] = set()
+
+# A full RFC 3339 local date-time: a calendar date, a ``T`` or space separator,
+# and a time to at least the second with an optional fraction, carrying no
+# offset. ``datetime.fromisoformat`` also accepts forms that are not RFC 3339
+# timestamps (a bare date, a week date, an hour-minute time); only this shape is
+# tolerated as an offset-less timestamp.
+_RFC3339_NAIVE_DATETIME = re.compile(r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?")
+
+
+def decode_optional_timestamp(value: object, *, source_url: str) -> datetime.datetime | None:
+    """Decode an optional RFC 3339 timestamp, treating an offset-less value as unknown.
+
+    A string with a full RFC 3339 date-time shape (a ``YYYY-MM-DD`` date, a ``T``
+    or space separator, and a time to at least the second with an optional
+    fraction) but no UTC offset violates RFC 3339 and has no defined meaning, so it
+    is reported once per service origin through the report channel and decodes to
+    ``None`` rather than being interpreted as UTC. ``None`` decodes to ``None`` and
+    an offset-bearing value (including a ``Z`` suffix) decodes to the aware
+    timestamp. Every other value -- a non-string, an unparseable string, or a
+    partial form such as a bare date or an hour-minute time -- raises.
+
+    :param value: Raw value to decode; ``None`` decodes to ``None``.
+    :param source_url: Redacted source URL of the serving document, used to derive
+        the service origin that scopes the once-per-origin deviation warning.
+    :return: The decoded offset-aware timestamp, or ``None`` when the value is
+        absent or is a full offset-less RFC 3339 date-time.
+    :raises ValueError: If the value is not ``None`` and is not a parseable,
+        full-shape RFC 3339 timestamp string.
+    """
+
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError("expected an RFC3339 timestamp string")
+    try:
+        decoded = datetime.datetime.fromisoformat(value)
+    except ValueError as exc:
+        raise ValueError(f"invalid RFC3339 timestamp {value!r}") from exc
+    if decoded.utcoffset() is not None:
+        return decoded
+    if _RFC3339_NAIVE_DATETIME.fullmatch(value) is not None:
+        split = urlsplit(source_url)
+        host = split.hostname or ""
+        if split.port is not None:
+            host = f"{host}:{split.port}"
+        origin = f"{split.scheme}://{host}" if split.scheme else source_url
+        if origin not in _naive_timestamp_origins_warned:
+            _naive_timestamp_origins_warned.add(origin)
+            logging.getLogger(__name__).warning(
+                "OPTIMADE service %s serves 'last_modified' without a UTC offset; the timestamp is treated as unknown",
+                origin,
+                extra={"context": "optimade"},
+            )
+        return None
+    raise ValueError(f"invalid RFC3339 timestamp {value!r}")
+
+
 @dataclass(frozen=True)
 class OptimadeEntryBackend:
     """Store one typed handle around an authoritative OPTIMADE resource.
@@ -159,7 +221,12 @@ class OptimadeEntryBackend:
 
     @property
     def _remote_names_by_definition_id(self) -> Mapping[str, str]:
-        """Map semantic property IRIs to remote names from the frozen info document."""
+        """Map semantic property IRIs to remote names from the frozen info document.
+
+        Declared ``$id`` definitions are authoritative. Any remaining standard
+        namespace names that the declared specification version identifies are
+        then filled in, for IRIs the declared map does not already contain.
+        """
 
         root = optimade_document_root(self.resource.schema.info_document)
         data = root.get("data")
@@ -186,6 +253,12 @@ class OptimadeEntryBackend:
                     f"{definition_id!r} to both {names[definition_id]!r} and {remote_name!r}"
                 )
             names[definition_id] = remote_name
+        from .standard_names import complete_standard_schema
+
+        completion = complete_standard_schema(self.resource.schema)
+        for remote_name, inferred_id in completion.definitions_by_name.items():
+            if inferred_id not in names:
+                names[inferred_id] = remote_name
         return MappingProxyType(names)
 
     def value_by_definition_id(self, definition_id: str, *, default: object = _MISSING) -> object:
@@ -256,9 +329,23 @@ class OptimadeEntryBackend:
 
     @stored_property
     def last_modified(self) -> datetime.datetime | None:
-        """Return the optional last-modified timestamp."""
+        """Return the optional last-modified timestamp.
 
-        return cast(datetime.datetime | None, self._portable_value("last_modified", datetime.datetime))
+        A value without a UTC offset violates RFC 3339 and has no defined meaning,
+        so it is treated as unknown (decoded to ``None`` with a once-per-origin
+        deviation warning) rather than being interpreted as UTC.
+        """
+
+        definition = self.local_schema.properties["last_modified"]
+        raw = self.value_by_definition_id(definition.definition_id)
+        if raw is _MISSING or raw is None:
+            return None
+        try:
+            return decode_optional_timestamp(raw, source_url=self.resource.document.source_url)
+        except ValueError as exc:
+            raise IncompleteOptimadeResourceError(
+                f"OPTIMADE semantic property 'last_modified' is invalid: {exc}"
+            ) from exc
 
     def _portable_value(self, name: str, expected_class: object) -> object:
         definition = self.local_schema.properties[name]
@@ -385,7 +472,15 @@ class OptimadeEntryView:
                 values[record_field.name] = None
                 continue
             try:
-                values[record_field.name] = self._backend.decode_value(definition, raw)
+                if record_field.name == "last_modified":
+                    # An optional timestamp without a UTC offset has no defined
+                    # meaning; decode it as unknown rather than assuming UTC,
+                    # exactly as the backend's typed accessor does.
+                    values[record_field.name] = decode_optional_timestamp(
+                        raw, source_url=self._backend.resource.document.source_url
+                    )
+                else:
+                    values[record_field.name] = self._backend.decode_value(definition, raw)
             except (TypeError, ValueError) as exc:
                 raise IncompleteOptimadeResourceError(
                     f"invalid semantic property {record_field.name!r}: {exc}"

httk_core-2.1.1/src/httk/core/optimade/standard_names.py

@@ -0,0 +1,260 @@
+"""Complete an OPTIMADE schema snapshot with standard-namespace name identities.
+
+Real OPTIMADE providers almost never publish a property-definition ``$id`` in
+their ``/info/<entry_type>`` documents, yet the specification reserves the
+unprefixed property namespace on a standard endpoint for the standard property
+of that name as of the specification version the service declares. This module
+applies that namespace rule: it fills in the definition IRI of an advertised
+unprefixed property name whose meaning the declared specification version fixes,
+without ever overriding a declared ``$id`` and without guessing about
+provider-prefixed names.
+
+The pure core is :func:`infer_standard_names`; :func:`complete_standard_schema`
+is the registry-driven wrapper that every code path building an
+:class:`~httk.core.optimade.resources.OptimadeSchemaSnapshot` can consult.
+"""
+
+import dataclasses
+import re
+from collections import Counter
+from collections.abc import Mapping
+from dataclasses import dataclass
+from threading import Lock
+from types import MappingProxyType
+from typing import cast
+from weakref import WeakKeyDictionary
+
+from ..property_definitions import EntryTypeDefinition
+from ..register.entries import OptimadeEntryBinding, known_optimade_entry_bindings, optimade_entry_binding
+from ..register.schemas import load_entry_type_definition
+from .entries import _is_definition_iri
+from .resources import OptimadeDocument, OptimadeSchemaSnapshot, optimade_document_root
+
+STANDARD_NAME_EVIDENCE = "standard-name"
+"""Evidence tag recorded for a name inferred from the standard namespace rule."""
+
+_VERSION = re.compile(r"^(\d+)\.(\d+)(?:\.\d+)?(?:[-+].*)?$")
+
+
+def parse_optimade_api_version(value: object) -> tuple[int, int] | None:
+    """Return the ``(major, minor)`` of a major-1 OPTIMADE version, or ``None``.
+
+    ``MAJOR.MINOR`` and ``MAJOR.MINOR.PATCH`` are accepted with optional trailing
+    pre-release or build text ignored. Only the ``(major, minor)`` pair is
+    compared. A value whose major version is not 1, or which does not parse,
+    yields ``None`` (the client supports major version 1 only).
+
+    :param value: Candidate version value.
+    :return: The ``(major, minor)`` pair, or ``None`` when unusable.
+    """
+
+    if not isinstance(value, str):
+        return None
+    match = _VERSION.match(value)
+    if match is None:
+        return None
+    major = int(match.group(1))
+    if major != 1:
+        return None
+    return (major, int(match.group(2)))
+
+
+@dataclass(frozen=True)
+class StandardSchemaCompletion:
+    """Identities inferred for standard-namespace property names.
+
+    :param entry_type: Entry type of the info document these names belong to.
+    :param api_version: Specification version the service declared, if any.
+    :param entry_type_definition_id: Definition IRI of the matched standard
+        entry type, set only when standard-name inference is possible for this
+        snapshot (a usable declared version and an owner-declared version
+        table); ``None`` otherwise.
+    :param definitions_by_name: Remote property name mapped to the property
+        definition IRI inferred for it.
+    :param evidence_by_name: Remote property name mapped to the evidence tag
+        that justified its inference.
+    """
+
+    entry_type: str
+    api_version: str | None
+    entry_type_definition_id: str | None
+    definitions_by_name: Mapping[str, str]
+    evidence_by_name: Mapping[str, str]
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "definitions_by_name", MappingProxyType(dict(self.definitions_by_name)))
+        object.__setattr__(self, "evidence_by_name", MappingProxyType(dict(self.evidence_by_name)))
+
+
+def infer_standard_names(
+    *,
+    entry_type: str,
+    api_version: str | None,
+    advertised: Mapping[str, object],
+    definition_ids_by_name: Mapping[str, str],
+    introduced_in: Mapping[str, str],
+) -> StandardSchemaCompletion:
+    """Infer definition IRIs for advertised standard-namespace property names.
+
+    Pure and registry-free. For each advertised name the standard namespace
+    rule is applied: an unprefixed name that the declared specification version
+    already defines is completed to that standard property's definition IRI. A
+    declared ``$id`` always wins, provider-prefixed names carry no standard
+    semantics, and a name introduced only in a later version stays unknown. An
+    absent or non-major-1 declared version disables inference entirely.
+
+    :param entry_type: Entry type being completed.
+    :param api_version: Specification version the service declared.
+    :param advertised: The info document's ``data.properties`` mapping.
+    :param definition_ids_by_name: Standard property name to definition IRI.
+    :param introduced_in: Standard property name to its earliest spec version.
+    :return: The names inferred for this schema, possibly empty.
+    """
+
+    declared = parse_optimade_api_version(api_version)
+    if declared is None:
+        return StandardSchemaCompletion(entry_type, api_version, None, {}, {})
+
+    declared_iris = {
+        cast(str, doc.get("$id"))
+        for doc in advertised.values()
+        if isinstance(doc, Mapping) and _is_definition_iri(doc.get("$id"))
+    }
+
+    inferred: dict[str, str] = {}
+    for name, document in advertised.items():
+        if not isinstance(name, str):
+            continue
+        if isinstance(document, Mapping) and _is_definition_iri(document.get("$id")):
+            # A declared identity is authoritative; never infer over it.
+            continue
+        if name.startswith("_"):
+            # Provider-prefixed names, and any other underscore-led name outside
+            # the well-formed prefix shape, are outside the standard namespace.
+            continue
+        iri = definition_ids_by_name.get(name)
+        if iri is None:
+            continue
+        introduced = parse_optimade_api_version(introduced_in.get(name))
+        if introduced is None or introduced > declared:
+            continue
+        inferred[name] = iri
+
+    # Declared identities win, and one IRI must never be claimed by two names.
+    inferred = {name: iri for name, iri in inferred.items() if iri not in declared_iris}
+    iri_counts = Counter(inferred.values())
+    inferred = {name: iri for name, iri in inferred.items() if iri_counts[iri] == 1}
+
+    evidence = {name: STANDARD_NAME_EVIDENCE for name in inferred}
+    return StandardSchemaCompletion(entry_type, api_version, None, inferred, evidence)
+
+
+_completion_cache: WeakKeyDictionary[OptimadeSchemaSnapshot, tuple[tuple[int, ...], StandardSchemaCompletion]] = (
+    WeakKeyDictionary()
+)
+_completion_cache_lock = Lock()
+
+
+def _registry_fingerprint() -> tuple[int, ...]:
+    # Identity of each currently registered binding. A binding re-registered
+    # under the same IRI is a different object, so this changes and invalidates
+    # a cached completion that resolved against the old table.
+    return tuple(id(optimade_entry_binding(definition_id)) for definition_id in known_optimade_entry_bindings())
+
+
+def _resolve_binding(entry_type: str) -> tuple[OptimadeEntryBinding, EntryTypeDefinition] | None:
+    matches: list[tuple[OptimadeEntryBinding, EntryTypeDefinition]] = []
+    for definition_id in known_optimade_entry_bindings():
+        binding = optimade_entry_binding(definition_id)
+        if binding is None:
+            continue
+        try:
+            definition = load_entry_type_definition(binding.definition_id)
+        except ValueError:
+            # A binding whose entry-type definition is not vendored here simply
+            # cannot be matched by name; skip it without failing the read.
+            continue
+        if definition.name == entry_type:
+            matches.append((binding, definition))
+    if len(matches) != 1:
+        return None
+    return matches[0]
+
+
+def _info_api_version(document: OptimadeDocument) -> str | None:
+    try:
+        root = optimade_document_root(document)
+    except ValueError:
+        return None
+    meta = root.get("meta")
+    if not isinstance(meta, Mapping):
+        return None
+    version = meta.get("api_version")
+    return version if isinstance(version, str) else None
+
+
+def _info_properties(document: OptimadeDocument) -> Mapping[str, object]:
+    try:
+        root = optimade_document_root(document)
+    except ValueError:
+        return {}
+    data = root.get("data")
+    if not isinstance(data, Mapping):
+        return {}
+    properties = data.get("properties")
+    if not isinstance(properties, Mapping):
+        return {}
+    return properties
+
+
+def _complete_standard_schema(snapshot: OptimadeSchemaSnapshot) -> StandardSchemaCompletion:
+    api_version = _info_api_version(snapshot.info_document)
+    resolved = _resolve_binding(snapshot.entry_type)
+    # ``entry_type_definition_id`` is set only when name-based inference is
+    # actually possible for this snapshot: a usable (major-1) declared version
+    # and a non-empty owner-declared version table. Otherwise it stays None, so
+    # a client never binds a typed backend that could identify nothing.
+    if resolved is None or parse_optimade_api_version(api_version) is None:
+        return StandardSchemaCompletion(snapshot.entry_type, api_version, None, {}, {})
+    binding, definition = resolved
+    versions = binding.standard_property_versions
+    if not versions:
+        return StandardSchemaCompletion(snapshot.entry_type, api_version, None, {}, {})
+    definition_ids_by_name = {name: prop.definition_id for name, prop in definition.properties.items()}
+    completion = infer_standard_names(
+        entry_type=snapshot.entry_type,
+        api_version=api_version,
+        advertised=_info_properties(snapshot.info_document),
+        definition_ids_by_name=definition_ids_by_name,
+        introduced_in=versions,
+    )
+    return dataclasses.replace(completion, entry_type_definition_id=definition.definition_id)
+
+
+def complete_standard_schema(snapshot: OptimadeSchemaSnapshot) -> StandardSchemaCompletion:
+    """Return the standard-name completion for one schema snapshot.
+
+    Registry-driven wrapper over :func:`infer_standard_names`. It reads the
+    declared specification version from the info document's own
+    ``meta.api_version``, resolves the standard entry type by name against the
+    registered OPTIMADE entry bindings, and gates name-based inference on that
+    binding's ``standard_property_versions`` table. It never raises for
+    malformed or hostile remote input: the safe answer is an empty completion.
+    ``entry_type_definition_id`` is set only when standard-name inference is
+    possible for this snapshot (a usable declared version and an owner-declared
+    version table).
+
+    :param snapshot: Schema snapshot whose advertised names to complete.
+    :return: The inferred completion, empty when unresolved or unsupported by
+        the declared version.
+    """
+
+    fingerprint = _registry_fingerprint()
+    with _completion_cache_lock:
+        cached = _completion_cache.get(snapshot)
+    if cached is not None and cached[0] == fingerprint:
+        return cached[1]
+    result = _complete_standard_schema(snapshot)
+    with _completion_cache_lock:
+        _completion_cache[snapshot] = (fingerprint, result)
+    return result

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk/core/register/entries.py

@@ -206,6 +206,12 @@ class OptimadeEntryBinding:
     :param view: The lazy view class reference.
     :param property_decoders: Property definition IRIs mapped to lazy decoder references.
     :param query_fields: Property definition IRIs supported for querying, if restricted.
+    :param standard_property_versions: Standard property names of this entry type
+        mapped to the earliest OPTIMADE specification version in which each name
+        is a standard property of the type. Declared by the entry-type owner, it
+        is the table that gates name-based inference of unprefixed properties
+        that carry no ``$id`` (see
+        :func:`~httk.core.optimade.standard_names.complete_standard_schema`).
     """
 
     name: str
@@ -214,6 +220,7 @@ class OptimadeEntryBinding:
     view: str
     property_decoders: Mapping[str, str] = field(default_factory=dict)
     query_fields: tuple[str, ...] | None = None
+    standard_property_versions: Mapping[str, str] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         _validate_nonempty_optimade_string(self.name, label="binding name")
@@ -236,7 +243,20 @@ class OptimadeEntryBinding:
                 if definition_id in seen:
                     raise ValueError(f"query field is listed more than once: {definition_id!r}")
                 seen.add(definition_id)
+        if not isinstance(self.standard_property_versions, Mapping):
+            raise TypeError("standard_property_versions must be a mapping of property names to spec versions")
+        from httk.core.optimade.standard_names import parse_optimade_api_version
+
+        versions: dict[str, str] = {}
+        for property_name, version in self.standard_property_versions.items():
+            _validate_nonempty_optimade_string(property_name, label="standard property name")
+            if not isinstance(version, str) or parse_optimade_api_version(version) is None:
+                raise ValueError(
+                    f"standard property version for {property_name!r} must be a major-1 OPTIMADE version string"
+                )
+            versions[property_name] = version
         object.__setattr__(self, "property_decoders", MappingProxyType(decoders))
+        object.__setattr__(self, "standard_property_versions", MappingProxyType(versions))
 
     def resolve_backend(self) -> type:
         """Import and return this binding's backend class on demand.
@@ -287,6 +307,7 @@ def register_optimade_entry_binding(
     view: str,
     property_decoders: Mapping[str, str] | None = None,
     query_fields: tuple[str, ...] | None = None,
+    standard_property_versions: Mapping[str, str] | None = None,
 ) -> None:
     """Register one lazy typed binding, selected only by exact definition IRI.
 
@@ -296,6 +317,11 @@ def register_optimade_entry_binding(
     :param view: The lazy view class reference.
     :param property_decoders: Property definition IRIs mapped to lazy decoder references.
     :param query_fields: Property definition IRIs supported for querying, if restricted.
+    :param standard_property_versions: Standard property names of this entry type
+        mapped to the earliest OPTIMADE specification version in which each name
+        is a standard property of the type. This table gates name-based
+        inference of unprefixed properties that a service advertises without a
+        ``$id`` definition.
     :raises ValueError: If the definition IRI is already registered or input is invalid.
     """
 
@@ -306,6 +332,7 @@ def register_optimade_entry_binding(
         view=view,
         property_decoders={} if property_decoders is None else property_decoders,
         query_fields=query_fields,
+        standard_property_versions={} if standard_property_versions is None else standard_property_versions,
     )
     if definition_id in _optimade_entry_bindings:
         raise ValueError(f"OPTIMADE entry binding is already registered: {definition_id!r}")

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk/registry/entries/core/__init__.py

@@ -36,12 +36,76 @@ register_entry_record(
     definition_id="https://schemas.optimade.org/defs/v1.2/entrytypes/optimade/references",
 )
 
+# Earliest OPTIMADE specification version in which each standard property name
+# is a property of this entry type (determined from the specification text at
+# release tags v1.0.1, v1.1.0, v1.2.0, v1.3.0). Gates standard-name inference
+# for services that publish no property-definition $id.
+_REFERENCES_INTRODUCED_IN = {
+    name: "1.0"
+    for name in (
+        "address",
+        "annote",
+        "authors",
+        "bib_type",
+        "booktitle",
+        "chapter",
+        "crossref",
+        "doi",
+        "edition",
+        "editors",
+        "howpublished",
+        "id",
+        "immutable_id",
+        "institution",
+        "journal",
+        "key",
+        "last_modified",
+        "month",
+        "note",
+        "number",
+        "organization",
+        "pages",
+        "publisher",
+        "school",
+        "series",
+        "title",
+        "type",
+        "url",
+        "volume",
+        "year",
+    )
+}
+# The files entry type itself first appears in OPTIMADE 1.2.
+_FILES_INTRODUCED_IN = {
+    name: "1.2"
+    for name in (
+        "atime",
+        "checksums",
+        "ctime",
+        "description",
+        "id",
+        "immutable_id",
+        "last_modified",
+        "media_type",
+        "modification_timestamp",
+        "mtime",
+        "name",
+        "size",
+        "type",
+        "url",
+        "url_stable_until",
+        "version",
+    )
+}
+_CALCULATIONS_INTRODUCED_IN = {name: "1.0" for name in ("id", "immutable_id", "last_modified", "type")}
+
 register_optimade_entry_binding(
     name="core-reference",
     definition_id="https://schemas.optimade.org/defs/v1.2/entrytypes/optimade/references",
     backend="httk.core.optimade.entries:OptimadeReference",
     view="httk.core.optimade.entries:ReferenceView",
     query_fields=None,
+    standard_property_versions=_REFERENCES_INTRODUCED_IN,
 )
 register_optimade_entry_binding(
     name="core-file",
@@ -49,6 +113,7 @@ register_optimade_entry_binding(
     backend="httk.core.optimade.entries:OptimadeFile",
     view="httk.core.optimade.entries:FileView",
     query_fields=None,
+    standard_property_versions=_FILES_INTRODUCED_IN,
 )
 register_optimade_entry_binding(
     name="core-calculation",
@@ -56,6 +121,7 @@ register_optimade_entry_binding(
     backend="httk.core.optimade.entries:OptimadeCalculation",
     view="httk.core.optimade.entries:CalculationView",
     query_fields=None,
+    standard_property_versions=_CALCULATIONS_INTRODUCED_IN,
 )
 register_entry_record(
     name="core-file",

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httk-core
-Version: 2.1.0
+Version: 2.1.1
 Summary: httk₂ core functionality
 Author-email: Rickard Armiento <rickard-gpg@armiento.net>
 License-Expression: AGPL-3.0-or-later

{httk_core-2.1.0 → httk_core-2.1.1}/src/httk_core.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ src/httk/core/docs/assets/selector.js
 src/httk/core/optimade/__init__.py
 src/httk/core/optimade/entries.py
 src/httk/core/optimade/resources.py
+src/httk/core/optimade/standard_names.py
 src/httk/core/optimade/filter/README.md
 src/httk/core/optimade/filter/__init__.py
 src/httk/core/optimade/filter/_miniparser.py
@@ -214,6 +215,8 @@ tests/test_numeric.py
 tests/test_operator_identity.py
 tests/test_optimade_filter.py
 tests/test_optimade_resources.py
+tests/test_optimade_standard_names.py
+tests/test_optimade_timestamps.py
 tests/test_plugins_cli.py
 tests/test_plugins_install.py
 tests/test_plugins_manifest.py
@@ -231,6 +234,8 @@ tests/test_provenance.py
 tests/test_records.py
 tests/test_registry_discovery.py
 tests/test_registry_tool.py
+tests/test_release_checker.py
+tests/test_release_prepare.py
 tests/test_report.py
 tests/test_saving.py
 tests/test_schema_check.py