odatapy 5.0.0__tar.gz

odatapy-5.0.0/.gitignore

@@ -0,0 +1,24 @@
+# Byte-compiled / cache
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Build / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Virtual envs
+.venv/
+venv/
+env/
+
+# IDE / OS
+.idea/
+.vscode/
+.DS_Store

odatapy-5.0.0/CHANGELOG.md

@@ -0,0 +1,387 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[PEP 440](https://peps.python.org/pep-0440/) versions.
+
+## [Unreleased]
+
+## [5.0.0] - 2026-09-09
+
+The first stable release. It follows 5.0.0b1 by a day and contains no new
+features: everything below came out of independently auditing the beta, running
+it against the public OData reference services, validating its metadata against
+the OASIS schemas, exercising it on Python 3.10 through 3.14, and driving it from
+several threads at once.
+
+Verified for this release: 1,983 tests pass on CPython 3.10, 3.11, 3.12, 3.13
+and 3.14, including ten that run over a real TCP socket; `ruff` and `mypy` are
+both clean; and the whole suite passes against the built sdist with the source
+tree removed.
+
+### Security
+- `Prefer: odata.maxpagesize` could raise the server's configured `page_size`,
+  so any client could ask for a million rows and read a whole collection in one
+  response, defeating the cap that `page_size` exists to enforce. The preference
+  now clamps the page size downwards only, as OData Part 1, 8.2.8.3 permits
+  (it asks for *at most* N results), and `Preference-Applied` reports the page
+  size actually used rather than the one requested. With no configured
+  `page_size` the client's request is still honoured in full.
+
+### Added
+- A documentation set under `docs/`: a tutorial, server and client guides, a
+  modelling guide, a query-option reference, a deployment guide and an
+  Olingo migration guide, plus interoperability results against the public
+  OData reference services. Every sample was executed before publication.
+
+### Fixed — found by interoperability testing
+Verified against the public OData reference services (TripPin, Northwind V4,
+ODataDemo) and against the OASIS CSDL XML and JSON schemas. Details, with
+reproductions and specification citations, are in `docs/INTEROP.md`.
+- A client read through a navigation segment was typed against the wrong entity
+  type, because only the first URL segment was resolved. `Customers('ALFKI')/Orders`
+  typed against `Customer`, so `Edm.DateTimeOffset`, `Guid`, `Duration`, `Binary`
+  and `Single` values stayed strings and `Edm.Double` came back as `Decimal`. The
+  whole resource path is now walked, and a payload's own `@odata.type` is honoured
+  when it names a derived type.
+- Reading a singleton through the client raised `AttributeError`.
+- `FunctionImport/@IncludeInServiceDocument` defaulted to true, so the service
+  document advertised function imports the model intended to hide. CSDL makes the
+  default false for a function import while leaving it true for an entity set.
+  The attribute is now emitted only when it differs from that default.
+- The `$expand` context URL omitted the select list, emitting
+  `#Categories/$entity` where the specification requires
+  `#Categories(Products(Name))/$entity`. Nested expands recurse, and a
+  `Nav/$ref` expansion is represented as such.
+- The `SRID` facet was not case-normalised, so `SRID="Variable"` produced a
+  spurious GeoJSON `crs` member and an invalid re-serialization. Metadata we
+  emit now validates against the OASIS XSD even when the source document does
+  not.
+- A `204 No Content` answer to a single-entity GET returned an empty `Entity`
+  from the client rather than `None`, so a caller could not tell "no entity"
+  from "an entity with no properties".
+- `text/plain` responses omitted `charset=utf-8` although the body was UTF-8.
+
+### Fixed
+- A `$apply` pipeline wrote its results back onto the stored entities, so a
+  `compute(... as X)` alias, and any navigation materialised by `expand(...)`,
+  stayed on the entity for the life of the process and appeared in later,
+  unrelated responses. A filtered `expand(...)` also shrank the stored
+  collection. Transformations now work on a shallow copy, and `groupby` copies a
+  complex or collection grouping value instead of putting the store's own object
+  in a response. The `$compute` query option was never affected, because the
+  in-memory processor already treated its aliases as transient.
+- `$apply=groupby(...)` returned 500 when the grouping property was a complex
+  property or a collection, such as `groupby((ShipTo))` or `groupby((Tags))`.
+  The grouping key has to be hashable, and the stringified key was being written
+  out as the value, so the payload contradicted the model. The key and the
+  emitted value are now kept apart, and the value carries its proper kind, so a
+  complex grouping property serializes as an object and a collection as an array.
+- `$filter` parameter aliases were never matched, so `Price gt @min` with
+  `@min=100` returned an empty collection with a 200 instead of the matching
+  rows. `uri_info.aliases` held raw query-string text, so the evaluator compared
+  a `Decimal` against the string `"100"`. Aliases are now parsed once, in the
+  URI parser, with the same literal grammar as any `$filter` literal, so
+  numbers, quoted strings, dates, times, durations, guids, binaries, booleans,
+  `null` and enum members all work, including inside a function call and in
+  `$compute` and `$orderby`. A value the grammar cannot parse, such as the JSON
+  of a complex or collection alias, is left as the original text, and the raw
+  text remains available as `uri_info.raw_aliases`.
+- The same bug made `odatapy.ext.sqlalchemy` bind an alias as a string, so
+  `@min=100` produced `Price > '100'`. Both SQL translators now accept typed
+  values and raw text.
+- `$expand=*` returned `null` for every single-valued navigation and `[]` for
+  every collection-valued one. The wildcard put a bare `"*"` key in the
+  serializer's expand map and skipped materialisation entirely. It is now
+  resolved into one item per navigation property, so each takes the same path as
+  an explicitly named one: materialised, honouring the star's own nested
+  options, and subject to `max_expand_depth` and the cycle check, so `*` over a
+  self-referencing navigation terminates as `$levels=max` does. An explicitly
+  named navigation still wins over the star.
+- The aggregation extension's `expand` transformation produced no navigation at
+  all. `$apply=expand(Products,filter(...))` only filtered an inline link, which
+  a store keeping its relationships outside the entity never creates, and the
+  serializer was never told to emit the navigation. It now materialises through
+  the back end's resolver and is reported to the serializer. A `groupby` later in
+  the pipeline projects onto its grouping properties, so the navigation is then
+  omitted rather than shown as a misleading empty array.
+
+### Changed
+- `UriInfo.aliases` now holds typed Python values rather than raw URI text. The
+  raw text moved to the new `UriInfo.raw_aliases`.
+- `InMemoryDataStore` and `InMemoryProcessor` are safe for concurrent use by
+  several threads in one process. The store guards every method with a reentrant
+  lock, and each processor entry point holds it across the whole
+  read-check-write sequence, so two simultaneous writes cannot interleave. The
+  store still lives in process memory, so a multi-worker deployment gives each
+  worker an independent copy.
+- The `dev` extra now installs `lxml` and `jsonschema`, without which the
+  metadata-validation tests skip silently, and continuous integration no longer
+  tolerates a type-check failure.
+- A new `sqlalchemy` extra installs the optional SQLAlchemy expression bridge.
+
+## [5.0.0b1] - 2026-09-09
+
+A feature-completeness release. The library grew from roughly 10,000 to about
+31,800 lines of Python, and the test suite from 204 to 1,826 cases, closing the
+gaps listed in `docs/OLINGO_COMPARISON.md`. See that document for what is
+covered, what is deliberately not ported, and what remains.
+
+An independent audit was run against the finished code, driving real requests
+rather than trusting the implementation. It found five defects that returned
+wrong answers or crashed, all of which are fixed and listed below.
+
+Nothing in the public API was removed, but the beta marker is deliberate: much of
+this surface is new and has only synthetic-service coverage.
+
+### Added — URI and query options
+- Resource paths: key-as-segment (`Products/1`), type-cast segments
+  (`Products/NS.Special`), `$crossjoin(A,B)`, `$all`, `$entity?$id=`, lambda
+  segments, function composition, and `$ref`/`$count`/`$value` position rules.
+- Key predicates are validated against the model (names, count, literal types)
+  and parameter aliases are resolved and typed.
+- `$filter`: the `in` operator with list literals, `any`/`all` lambdas with
+  variable binding, `$it`, `$root`, `has`, `hassubset`/`hassubsequence`,
+  `cast`/`isof` with real type references, `matchesPattern`, the full date, math,
+  string and geo function set, and method arity checking.
+- Expressions are bound to the EDM: unknown properties are rejected with 400,
+  operand types are checked, and literals are typed per the ABNF (integers by
+  range, `1.5` as `Edm.Decimal`, suffixed forms as Double/Single/Decimal).
+- `$search` is parsed into an expression tree (terms, phrases, `AND`/`OR`/`NOT`,
+  grouping) and evaluated, replacing the previous implicit-AND word match.
+- `$apply` is parsed into typed transformations and evaluated: `aggregate` with
+  `sum`/`min`/`max`/`average`/`countdistinct`/`$count` and `from`, nested
+  `groupby`, `filter`, `compute`, `expand`, `concat`, `search`, `identity`, and
+  the `topcount`/`bottomcount`/`topsum`/`bottomsum`/`toppercent`/`bottompercent`
+  family.
+- `$compute`, `$deltatoken`, `$index` and `$schemaversion` are supported;
+  duplicate system options, malformed `$count`/`$top`/`$skip` values, and query
+  options on `$metadata`/`$batch` are rejected.
+- The URI validator implements the full method-by-resource-kind-by-option matrix
+  and exposes `allowed_methods()` for the `Allow` header.
+- Resource-not-found now returns 404 rather than 400, via a distinct semantic
+  exception.
+
+### Added — evaluation
+- Strict three-valued null logic throughout `$filter`, so null operands
+  propagate instead of raising, with equality remaining null-aware so
+  `Description eq null` still matches.
+- Date arithmetic, integer division truncation, division by zero as null, and
+  numeric coercion across int, Decimal and float.
+
+### Added — EDM, metadata and serialization
+- A vocabulary annotation model covering constant and dynamic expressions
+  (`Path`, `Apply`, `If`, `Record`, `Collection`, comparison and logical
+  operators, `Cast`, `IsOf`, `UrlRef`, labelled elements), serialized in both
+  CSDL formats and parsed back.
+- `$metadata` XML: `edmx:Reference`/`Include`/`IncludeAnnotations`, `Term`,
+  `TypeDefinition`, out-of-line `Annotations`, annotations on every element,
+  `Scale="variable"`/`"floating"`, SRID, `Unicode`, `DefaultValue`, `Abstract`,
+  `OpenType`, `HasStream`, complex `BaseType`, `OnDelete`, `ContainsTarget`,
+  `Partner`, container `Extends`, singleton bindings, and version 4.0 or 4.01
+  by service version.
+- `$metadata` JSON CSDL is now complete (actions, functions, imports, type
+  definitions, `$IsFlags`, key aliases, per-property annotations) and a new
+  CSDL-JSON parser lets the client consume it.
+- Both metadata formats round-trip exactly through the parsers.
+- JSON payloads: derived types with `@odata.type` and derived-type context URLs,
+  `$select` context suffixes, `Nav@odata.count`/`@odata.nextLink`,
+  `$expand=Nav/$ref`, the full `odata.metadata=full` annotation set including
+  navigation, association, edit, read and media links and operation
+  advertisement, `IEEE754Compatible`, exact Decimal digits without float
+  rounding, enum member names including flags, `omit-values`, 4.01 short control
+  names, and `innererror`.
+- Delta payloads in both the 4.0 (`$deletedEntity`) and 4.01 (`@removed`) shapes,
+  including added and deleted links.
+- Atom/XML is now a first-class format: feeds and entries with the required Atom
+  members, self and edit links, related links with `m:inline` expansion, media
+  entries, references, delta feeds, the correct APP namespace for service
+  documents, and errors with details and inner error.
+- Deserializers (JSON and XML) validate types and facets, honour `@odata.type`
+  casts, keep dynamic properties on open types, offer a strict mode, and handle
+  action parameters and entity collections.
+
+### Added — server runtime
+- `OData-Version` and `OData-MaxVersion` are validated and negotiated, and the
+  negotiated version is stamped on every response including 204, 304 and errors.
+- Status codes now follow the protocol: 406 for negotiation failure, 415 for an
+  unsupported request media type, 412 and 428 for preconditions, 501 for
+  unimplemented operations, and a generic 500 that never leaks a traceback.
+- All `Prefer` options are honoured with an accurate `Preference-Applied`:
+  `return=representation`/`minimal`, `odata.maxpagesize`, `continue-on-error`,
+  `respond-async` with `wait`, `include-annotations`, `track-changes`,
+  `allow-entityreferences` and `omit-values`.
+- `OData-EntityId` on minimal creates, ETags regenerated on every write, weak
+  comparison, `If-Match` lists and `*`, `If-None-Match` producing 304 or 412,
+  and ETags on `$metadata` and the service document.
+- `HEAD` and `OPTIONS` are supported, the latter returning an `Allow` header.
+- A debug facility behind an authorization hook renders request, response, URI,
+  server, exception and timing detail as JSON or HTML.
+- Extension hooks for custom content types, custom ETags, service-metadata
+  ETags and batch transactions.
+- The processor surface now matches Olingo's: primitive and complex collection
+  processors with counts, reference collections, media delete, and operation
+  dispatch by return type.
+- `$batch` was rewritten as a byte-level parser: binary parts survive intact,
+  boundaries and part headers are validated, changesets are atomic with
+  rollback, `$<id>` references are resolved in the request line and inside
+  `@odata.bind` by parsing the JSON body rather than replacing bytes, and the
+  OData 4.01 JSON batch format is supported with `atomicityGroup` and
+  `dependsOn`.
+- Adapters honour `SCRIPT_NAME` and ASGI `root_path`, read bodies with no
+  `Content-Length`, optionally trust `X-Forwarded-*`, percent-decode paths
+  without breaking segment structure, and stream iterator bodies.
+- The in-memory reference processor gained a real relation table, so navigation
+  paths work for reads and writes; duplicate keys return 409 and missing keys
+  400; paging is stable; nested `$expand` options are applied per item; change
+  tracking serves delta payloads; and `respond-async` runs on a thread pool with
+  polling and cancellation.
+
+### Added — client
+- An `AsyncODataClient` sharing all request building and payload parsing with the
+  synchronous client, so both return identical values.
+- A complete retrieve surface including `iter_entities` paging through
+  `@odata.nextLink`, typed service documents, `$value`, media streaming, delta
+  reads and reference reads.
+- Reference and media write operations, property deletes, raw `$value` writes,
+  and deep insert.
+- A `$batch` builder supporting changesets, content-ID cross references and both
+  the multipart and JSON formats.
+- Authentication classes for basic, bearer and OAuth2 client credentials, a
+  retry policy honouring `Retry-After`, redirects, timeouts and request hooks.
+- `$metadata` revalidation with `If-None-Match`, and JSON CSDL support.
+- The SQL extension escapes LIKE wildcards, supports lambdas as `EXISTS`
+  subqueries, binds parameter aliases, and emits `ORDER BY` and `LIMIT`/`OFFSET`
+  with three bind styles. An optional SQLAlchemy bridge is available as the
+  `sqlalchemy` extra.
+
+### Fixed — found by the audit
+- Navigation traversal in `$filter` and `$orderby` silently matched nothing.
+  `$filter=Friends/any(f: f/Name eq 'Bob')`, `Manager/Name eq 'Bob'` and
+  `$orderby=Manager/Name` all returned wrong results with a 200, because the
+  evaluator only saw inline links and never consulted the relation table.
+- `$expand` with `$levels=max` on a self-referencing navigation recursed until
+  the stack ran out, returning 500. Depth is now capped and cycles detected.
+- A type-cast path segment on a collection did not filter, so
+  `People/NS.Employee` returned every person, and a cast to a type the entity
+  does not have returned the entity instead of 404.
+- The client's JSON reader converted `Edm.Decimal` through `float`, so a
+  twenty-digit value came back rounded and `10.50` lost its scale. JSON and XML
+  reads now agree exactly.
+- `IEEE754Compatible=true` was echoed in `Content-Type` but ignored, so
+  `Edm.Int64` and `Edm.Decimal` were still written as bare JSON numbers.
+- Geospatial properties could never be written through JSON: the deserializer
+  rejected the GeoJSON object as "not a scalar".
+- `$compute` was parsed and then discarded, so `$select`, `$filter` and
+  `$orderby` rejected its aliases as unknown properties.
+- Composable function results could not be composed: `Fn()/$count`, `Fn()(key)`
+  and `Fn()/Property` all failed.
+- `$apply=from(...)` was unimplemented, and an unknown path in `from`,
+  `aggregate ... from` or `groupby` was accepted and silently evaluated to an
+  empty set instead of returning 400.
+- An aggregate over an empty or all-null set returned `0` instead of null.
+- A response could carry a higher `OData-Version` than the client declared.
+- `Prefer: continue-on-error` was ignored under its 4.01 name.
+- A PATCH or PUT that changed a key was accepted and silently ignored.
+- `$skiptoken` was an offset, so deleting a row between pages skipped a row.
+  Paging is now key-based and stable.
+- `CustomETagSupport` and `DebugSupport` crashed `handler.register()`.
+- Strict deserialization was unreachable, so unknown properties on closed types
+  were always ignored.
+- JSON batch `dependsOn` referencing an unknown request id returned 200.
+- `SRID` facets were never validated on write.
+- The XML deserializer accepted a scalar where a collection was declared, and
+  silently discarded a collection given as a bare text node.
+- `geo.intersects` excluded points lying exactly on a polygon boundary.
+- A delta window that created and then deleted an entity reported it as added.
+
+### Fixed — other
+- The in-memory processor called the XML serializer for single properties with an
+  argument it did not accept, so any XML property request returned 500.
+- GeoJSON output no longer emits a `crs` member for a default SRID.
+- The XML serializer was missing the collection, reference and delta methods the
+  in-memory processor calls, so those endpoints crashed for XML requests.
+- Posting a media entity to a path that resolves without an entity set, such as a
+  singleton or navigation target, crashed with 500 instead of returning 400.
+- `$all` and the internal all-entities walk crashed on a schema declaring no
+  entity container.
+
+### Changed
+- The whole package now type-checks cleanly under mypy. Three annotations that
+  were simply wrong were corrected, all on internals:
+  `TypeLiteral.edm_type` accepts a raw primitive type,
+  `ODataHandler.select_processor` is no longer bounded to `Processor` because the
+  support mixins are not processors, and `EdmPrimitiveType.uri_prefix`/`uri_suffix`
+  are no longer `ClassVar` because geospatial types bind them per instance.
+
+## [5.0.0a2] - 2026-09-08
+
+Follow-up to the 5.0.0a1 hardening after a second review pass.
+
+### Fixed
+- Request-body validation: wrong JSON types, non-nullable nulls, out-of-range
+  integers and Decimal precision/scale violations in entity, complex and
+  property bodies now return 400 with the offending property named, instead of
+  500 or silent coercion.
+- `PUT .../Property/$value` honours the EDM property's Decimal/Duration
+  facets (a `Price` with `Scale="2"` accepts `3.14`), and `Edm.Binary`
+  `$value` bodies are stored as raw octets.
+- Key properties can no longer be modified through property `PUT`/`PATCH` or
+  `$value`.
+- Property updates with a non-JSON request body return 415 instead of 500.
+- Malformed key literals (`Products('abc')` on an `Edm.Int32` key) return 400
+  instead of 500.
+- Non-finite `Edm.Decimal` and untyped float values are serialized as
+  `"INF"`, `"-INF"`, `"NaN"` like `Edm.Double`; `"INF"`/`"NaN"` strings are
+  accepted on input for `Edm.Double`/`Edm.Single`.
+- `Edm.Duration` values with fractional seconds no longer fail to serialize
+  or deserialize when no EDM facets are available (dynamic values, client
+  reads); a declared property without `Precision` still means precision 0,
+  as the CSDL specification requires.
+- `Edm.Binary` is emitted with the base64url alphabet required by the OData
+  ABNF (server and client).
+- `$filter`, `$orderby`, `$search` and `/$count` now apply to the result of
+  `$apply` instead of being skipped when `$apply` is present.
+- Client raises `ODataServerError` (a subclass of `ODataClientError`) for
+  5xx responses; it is exported from `odatapy.client`.
+
+## [5.0.0a1] - 2026-09-08
+
+First public alpha. The version number tracks the Apache Olingo release the
+library is modelled on (5.0.0); it does **not** claim feature parity. See
+`docs/OLINGO_COMPARISON.md` for the coverage matrix and known gaps.
+
+### Added
+- EDM type system: all OData primitive types with literal grammars and facets,
+  CSDL provider model, runtime EDM, `$metadata` XML and JSON CSDL output and
+  XML parsing, geospatial types (WKT and GeoJSON).
+- Transport-neutral server pipeline with ASGI and WSGI adapters, consolidated
+  processor protocols, and a reusable in-memory reference processor.
+- URI and query-option parsing: resource paths, `$filter` expression tree with
+  visitor, `$select`, `$expand` (nested options, `$levels`), `$orderby`, `$top`,
+  `$skip`, `$count`, `$search`, `$format`, `$apply` (filter/aggregate/groupby).
+- JSON payload serialization (metadata levels none/minimal/full) and Atom/XML
+  payloads, delta responses, media entities, `$ref`, singletons, bound and
+  unbound operations, deep insert, `$batch` with changesets, ETag preconditions,
+  server-driven paging, and the `Prefer: respond-async` protocol.
+- Client: fluent `URIBuilder`, `$filter` builder, CRUD and operation calls,
+  `$metadata` to EDM with caching, JSON and XML response reading, httpx
+  transports, and an in-process transport for tests.
+- `odatapy.ext.sql`: `$filter` tree to parameterised SQL `WHERE` clause.
+
+### Fixed (pre-release hardening)
+- `X-HTTP-Method` / `X-HTTP-Method-Override` tunnelling is honoured only on
+  POST requests, and an unknown tunnelled verb no longer silently becomes GET.
+- `Edm.Double` / `Edm.Single` infinities and NaN are serialized as the JSON
+  strings `"INF"`, `"-INF"`, `"NaN"` instead of invalid JSON tokens.
+- `@odata.count` honours `$filter` and `$search` instead of counting the whole
+  entity set.
+- `$orderby` places nulls first for ascending and last for descending order, as
+  the specification requires.
+- Client `URIBuilder` replaces a system query option that is set twice instead
+  of emitting it twice, and percent-encodes path segments and key literals.
+- Client `get_property_value` handles raw `$value` responses; `invoke_action`
+  serializes `Decimal`, `datetime`, `UUID` and `bytes` parameters; `bytes`
+  property values are written as base64; `update_entity(method="REPLACE")`
+  maps to PUT; `ODataClientError` no longer raises while parsing a non-object
+  error body.

odatapy-5.0.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

odatapy-5.0.0/NOTICE

@@ -0,0 +1,7 @@
+odatapy
+Copyright 2026 Beroe Inc.
+
+This product is a Python port of Apache Olingo OData 4 (https://olingo.apache.org/),
+Copyright The Apache Software Foundation, licensed under the Apache License 2.0.
+Protocol behaviour, type-system semantics and API naming follow Apache Olingo;
+no Apache Olingo source code is redistributed in this package.