onedata-lambda-sdk 1.0.0__py3-none-any.whl

onedata_lambda_sdk/testing.py

@@ -0,0 +1,316 @@
+"""
+Helpers for unit-testing lambda handlers without Docker, network, or the runtime.
+
+Build a synthetic context and jobs, call your handler directly, then assert on both its
+return value and its side effects -- heartbeats, logs and streamed items, captured in
+memory per name:
+
+    from onedata_lambda_sdk.testing import build_job_context, build_jobs
+
+    rc = build_job_context(config={"threshold": 5})
+    results = handle(build_jobs([{"x": 1}, {"x": 2}]), rc.context)
+
+    assert results == [...]
+    assert rc.heartbeats == 2
+    assert rc.streams["stats"] == [...]
+    assert rc.logs["logs"] == [{"severity": "info", "content": "..."}]
+
+Works for batch handlers and for `@per_job` handlers alike -- a decorated
+per-job handler already has the batch signature. To test the per-job function in
+isolation, call it with a single `build_jobs([...])[0]` and `rc.context`.
+
+For an end-to-end check through the *real* runtime, use `run_local`:
+
+    from onedata_lambda_sdk.testing import build_request, run_local
+
+    result = run_local(handle, build_request([{"x": 1}], config={"k": "v"}), out_dir=tmp_path)
+    assert result.envelope == {"resultsBatch": [...]}
+    assert result.streams["stats"] == [...]
+
+It drives `run(handler, raw)` in dev mode and returns the response envelope plus the items
+each `/out/<stream>` received -- exercising the seam the unit helpers skip (wire parsing,
+`JobContext` construction, the buffered flusher writing files, envelope assembly).
+"""
+
+__author__ = "Bartosz Walkowicz"
+__copyright__ = "Copyright (C) 2026 Onedata (onedata.org)"
+__license__ = "This software is released under the MIT license cited in LICENSE.txt"
+
+import contextlib
+import json
+import os
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass
+from typing import Any
+
+from ._wire import AtmJobBatchRequestCtx
+from .job import Job, JobContext
+from .logging import Logger
+from .runtime import ENV_DEV_MODE, run
+from .streaming import ResultStreamer
+from .types import AtmObject, LogLevel
+
+
+# --- Unit testing: the handler in isolation ------------------------------------------
+# Drive a handler directly against a synthetic JobContext whose services (heartbeat,
+# streamers, loggers) record into memory instead of touching the network or `/out`.
+
+
+class _Counter:
+    """A mutable integer cell shared between the heartbeat closure and `RecordedContext`."""
+
+    def __init__(self) -> None:
+        self.value = 0
+
+    def increment(self) -> None:
+        self.value += 1
+
+
+class _RecordingStreamer(ResultStreamer[Any]):
+    """A streamer that captures items in a list instead of writing to `/out`."""
+
+    # Deliberately bypasses ResultStreamer.__init__ (no flusher/heartbeat/out_dir needed):
+    # both public methods are overridden to append to the sink, so no inherited code runs.
+    def __init__(self, result_name: str, sink: list[Any]) -> None:
+        self.result_name = result_name
+        self._sink = sink
+
+    def stream_item(self, item: Any) -> None:
+        self._sink.append(item)
+
+    def stream_items(self, items: Iterable[Any]) -> None:
+        self._sink.extend(items)
+
+
+class _RecordingLogger(Logger):
+    """A logger that captures all entries (no level filtering) instead of writing out."""
+
+    # Like _RecordingStreamer, bypasses the parent __init__; stream_items is overridden to
+    # capture every entry, so the level threshold the real Logger applies is intentionally
+    # skipped -- a test sees all emitted logs regardless of `log_level`.
+    def __init__(self, result_name: str, sink: list[AtmObject]) -> None:
+        self.result_name = result_name
+        self._sink = sink
+
+    def stream_items(self, items: Iterable[AtmObject]) -> None:
+        self._sink.extend(items)
+
+
+class RecordedContext:
+    """A synthetic `JobContext` plus the side effects captured during a test."""
+
+    def __init__(
+        self,
+        context: JobContext[Any],
+        logs: dict[str, list[AtmObject]],
+        streams: dict[str, list[Any]],
+        heartbeats: _Counter,
+    ) -> None:
+        self.context = context
+        # Log entries the handler emitted, keyed by log stream name (captured regardless of
+        # level -- the recording logger does not filter; see _RecordingLogger).
+        self.logs = logs
+        # Streamed items keyed by stream name.
+        self.streams = streams
+        self._heartbeats = heartbeats
+
+    @property
+    def heartbeats(self) -> int:
+        """
+        How many times the handler called `ctx.heartbeat()` explicitly.
+
+        Unlike the real runtime, the recording streamers/loggers do not emit heartbeats,
+        so this counts only direct `ctx.heartbeat()` calls.
+        """
+        return self._heartbeats.value
+
+
+def build_jobs(args_batch: list[Any]) -> list[Job[Any]]:
+    """Wrap a list of argument objects into `Job`s with synthetic trace ids."""
+    return [Job(args=args, trace_id=f"test-{i}") for i, args in enumerate(args_batch)]
+
+
+def build_job_context(
+    *,
+    config: Any = None,
+    log_level: LogLevel = "info",
+    user_id: str = "test-user",
+    space_id: str = "test-space",
+    workflow_execution_id: str = "test-workflow-execution",
+    oneprovider_id: str = "test-oneprovider",
+    oneprovider_domain: str = "oneprovider.test",
+    onezone_domain: str = "onezone.test",
+    access_token: str = "test-token",
+    timeout_seconds: int = 120,
+) -> RecordedContext:
+    """
+    Build a synthetic `JobContext` whose services record into memory.
+
+    Returns a `RecordedContext` exposing the context (`.context`) plus the captured
+    `.logs`, `.streams` and `.heartbeats`.
+
+    Note: captured logs are *not* level-filtered -- `log_level` is stored on the context,
+    but the recording logger keeps every entry, so a test sees all emitted logs. To
+    exercise real level filtering, go through `run_local`.
+    """
+    logs: dict[str, list[AtmObject]] = {}
+    streams: dict[str, list[Any]] = {}
+    heartbeats = _Counter()
+
+    def heartbeat() -> None:
+        heartbeats.increment()
+
+    streamers: dict[str, _RecordingStreamer] = {}
+
+    def result_streamer_factory(name: str, *, buffered: bool = True) -> ResultStreamer[Any]:
+        streamer = streamers.get(name)
+        if streamer is None:
+            streamer = _RecordingStreamer(name, streams.setdefault(name, []))
+            streamers[name] = streamer
+        return streamer
+
+    loggers: dict[str, _RecordingLogger] = {}
+
+    def logger_factory(name: str) -> Logger:
+        logger = loggers.get(name)
+        if logger is None:
+            logger = _RecordingLogger(name, logs.setdefault(name, []))
+            loggers[name] = logger
+        return logger
+
+    raw: AtmJobBatchRequestCtx[Any] = AtmJobBatchRequestCtx(
+        userId=user_id,
+        spaceId=space_id,
+        atmWorkflowExecutionId=workflow_execution_id,
+        oneproviderId=oneprovider_id,
+        oneproviderDomain=oneprovider_domain,
+        onezoneDomain=onezone_domain,
+        accessToken=access_token,
+        heartbeatUrl="",
+        timeoutSeconds=timeout_seconds,
+        logLevel=log_level,
+        config=config,
+    )
+
+    context: JobContext[Any] = JobContext(
+        config=config,
+        user_id=user_id,
+        space_id=space_id,
+        workflow_execution_id=workflow_execution_id,
+        oneprovider_id=oneprovider_id,
+        oneprovider_domain=oneprovider_domain,
+        onezone_domain=onezone_domain,
+        access_token=access_token,
+        timeout_seconds=timeout_seconds,
+        log_level=log_level,
+        heartbeat=heartbeat,
+        result_streamer_factory=result_streamer_factory,
+        logger_factory=logger_factory,
+        raw=raw,
+    )
+    return RecordedContext(context, logs, streams, heartbeats)
+
+
+# --- Integration testing: through the real run() -------------------------------------
+# Drive the real runtime end-to-end in dev mode against an in-memory wire request and
+# capture what reached the response envelope and the `/out/<stream>` files.
+
+
+@dataclass
+class LocalRunResult:
+    """The outcome of `run_local`: the response envelope plus captured stream contents."""
+
+    # The dict `run()` returned -- `{"resultsBatch": [...]}` or `{"exception": ...}`.
+    envelope: dict[str, Any]
+    # Items written to each `/out/<name>` stream during the run (parsed JSON lines), by name.
+    streams: dict[str, list[Any]]
+
+
+def build_request(
+    args_batch: list[Any],
+    *,
+    config: Any = None,
+    log_level: LogLevel = "info",
+    user_id: str = "test-user",
+    space_id: str = "test-space",
+    workflow_execution_id: str = "test-workflow-execution",
+    oneprovider_id: str = "test-oneprovider",
+    oneprovider_domain: str = "oneprovider.test",
+    onezone_domain: str = "onezone.test",
+    access_token: str = "test-token",
+    heartbeat_url: str = "https://heartbeat.test",
+    timeout_seconds: int = 120,
+) -> dict[str, Any]:
+    """
+    Build a raw wire request (the dict `run()` parses), with a per-job `__meta.traceId`.
+
+    The integration-layer counterpart to `build_jobs`/`build_job_context`: pass the result to
+    `run_local` (or `json.dumps` it and call `run` yourself). Each item of `args_batch` is one
+    job's arguments; the `__meta` envelope the framework adds on the wire is injected here.
+    """
+    return {
+        "ctx": {
+            "userId": user_id,
+            "spaceId": space_id,
+            "atmWorkflowExecutionId": workflow_execution_id,
+            "oneproviderId": oneprovider_id,
+            "oneproviderDomain": oneprovider_domain,
+            "onezoneDomain": onezone_domain,
+            "accessToken": access_token,
+            "heartbeatUrl": heartbeat_url,
+            "timeoutSeconds": timeout_seconds,
+            "logLevel": log_level,
+            "config": config,
+        },
+        "argsBatch": [
+            {**args, "__meta": {"traceId": f"test-{i}"}} for i, args in enumerate(args_batch)
+        ],
+    }
+
+
+def run_local(
+    handler: Callable[..., Any],
+    request: dict[str, Any] | str,
+    *,
+    out_dir: str | os.PathLike[str],
+) -> LocalRunResult:
+    """
+    Drive the real runtime `run(handler, raw)` in dev mode and capture its side effects.
+
+    Runs in dev mode (`ONEDATA_LAMBDA_DEV=1`: heartbeats logged not POSTed, no stdout
+    redirect, no Oneclient mount-wait) with the streaming output directory pointed at
+    `out_dir` (pass a pytest `tmp_path`). Returns the response envelope plus the items each
+    stream received, so an integration test can assert on both -- the seam unit tests skip:
+    wire parsing, `JobContext` construction, the buffered flusher writing files, and
+    envelope assembly.
+
+    `request` is a wire request dict (see `build_request`) or a raw JSON string.
+    """
+    raw = request if isinstance(request, str) else json.dumps(request)
+    with _dev_mode():
+        envelope = run(handler, raw, out_dir=os.fspath(out_dir))
+    return LocalRunResult(envelope=dict(envelope), streams=_read_streams(out_dir))
+
+
+@contextlib.contextmanager
+def _dev_mode() -> Iterator[None]:
+    previous = os.environ.get(ENV_DEV_MODE)
+    os.environ[ENV_DEV_MODE] = "1"
+    try:
+        yield
+    finally:
+        if previous is None:
+            os.environ.pop(ENV_DEV_MODE, None)
+        else:
+            os.environ[ENV_DEV_MODE] = previous
+
+
+def _read_streams(out_dir: str | os.PathLike[str]) -> dict[str, list[Any]]:
+    streams: dict[str, list[Any]] = {}
+    for name in sorted(os.listdir(out_dir)):
+        path = os.path.join(os.fspath(out_dir), name)
+        if not os.path.isfile(path):
+            continue
+        with open(path) as stream_file:
+            streams[name] = [json.loads(line) for line in stream_file if line.strip()]
+    return streams

onedata_lambda_sdk/types.py

@@ -0,0 +1,179 @@
+"""
+Public data types for Onedata Automation lambdas: the JSON shapes of Onedata entities a
+handler receives or produces (`AtmFile`, `AtmDataset`, `AtmObject`, …), mirroring the
+public Onedata API, plus `AtmException` (the per-job failure marker).
+"""
+
+__author__ = "Bartosz Walkowicz"
+__copyright__ = "Copyright (C) 2022-2026 Onedata (onedata.org)"
+__license__ = "This software is released under the MIT license cited in LICENSE.txt"
+
+from typing import Any, Literal, NotRequired, TypedDict
+
+
+##===================================================================
+## Basic automation data types
+##===================================================================
+
+
+type FileType = Literal["REG", "DIR", "SYMLNK"]
+type ProtectionFlag = Literal["data_protection", "metadata_protection"]
+type InheritancePath = Literal["none", "direct", "ancestor", "direct_and_ancestor"]
+type LogLevel = Literal[
+    "debug",
+    "info",
+    "notice",
+    "warning",
+    "error",
+    "critical",
+    "alert",
+    "emergency",
+]
+
+type AtmObject = dict[str, Any]
+"""Generic JSON object."""
+
+
+class AtmDataset(TypedDict):
+    """
+    JSON object describing dataset.
+
+    Refer to the API specification for more information:
+    https://onedata.org/#/home/api/latest/oneprovider?anchor=operation/get_dataset
+    """
+
+    state: Literal["attached", "detached"]
+    datasetId: str
+    parentId: str | None
+    rootFileId: str
+    rootFileType: FileType
+    rootFilePath: str
+    rootFileDeleted: bool
+    protectionFlags: list[ProtectionFlag]
+    effectiveProtectionFlags: list[ProtectionFlag]
+    creationTime: int
+    archiveCount: int
+
+
+class AtmFile(TypedDict, total=False):
+    """
+    JSON object describing a file in Onedata filesystem.
+
+    Refer to the API specification for more information:
+    https://onedata.org/#/home/api/latest/oneprovider?anchor=operation/get_attrs
+
+    NOTE: dynamic fields like `xattr.*` are not typed due to limitations
+    of typing machinery.
+    """
+
+    fileId: str
+    index: str
+    type: FileType
+    activePermissionsType: Literal["posix", "acl"]
+    posixPermissions: str
+    acl: list[dict]
+    name: str
+    conflictingName: str | None
+    path: str
+    parentFileId: str | None
+    displayGid: int
+    displayUid: int
+    atime: int
+    mtime: int
+    ctime: int
+    size: int | None
+    isFullyReplicatedLocally: bool | None
+    localReplicationRate: float
+    originProviderId: str
+    directShareIds: list[str]
+    ownerUserId: str
+    hardlinkCount: int
+    symlinkValue: str | None
+    hasCustomMetadata: bool
+    effProtectionFlags: list[ProtectionFlag]
+    effDatasetProtectionFlags: list[ProtectionFlag]
+    effDatasetInheritancePath: InheritancePath
+    effQosInheritancePath: InheritancePath
+    aggregateQosStatus: Literal["fulfilled", "pending", "impossible"]
+    archiveRecallRootFileId: str | None
+
+
+class AtmGroup(TypedDict):
+    """
+    JSON object describing group.
+
+    Refer to the API specification for more information:
+    https://onedata.org/#/home/api/latest/onezone?anchor=operation/get_group
+    """
+
+    groupId: str
+    name: str
+    type: Literal["organization", "unit", "team", "role_holders"]
+
+
+class AtmRange(TypedDict):
+    """
+    JSON object describing a sequence of integers.
+
+    AtmRange is a sequence of integers produced from the start to end by step.
+
+    Fields
+    --------
+    end
+        Value for which the sequence of integers will exclusively end.
+        If step value is positive, end value must be higher than start value.
+        Otherwise end value must be lower than start value.
+    start
+        Starting value for which the sequence of integers will inclusively start.
+        If step value is positive, start value must be lower than end value.
+        Otherwise start value must be higher than end value.
+        By default, it's set to: 0.
+    step
+        Value which specifies the size of incrementation or decrementation.
+        It cannot be equal 0, and by default, it's set to: 1.
+
+    Examples
+    --------
+    AtmRange(start=10, end=20, step=2) -> [10, 12, 14, 16, 18]
+    AtmRange(start=10, end=-10, step=-4) -> [10, 6, 2, -2, -6]
+    AtmRange(end=10, step=6) -> [0, 6]
+    AtmRange(end=5) -> [0, 1, 2, 3, 4]
+    AtmRange(start=4, end=-1, step=-1) -> [4, 3, 2, 1, 0]
+    AtmRange(start=5, end=5, step=-2) -> []
+    AtmRange(start=4, end=5, step=-2) -> Invalid!
+    """
+
+    end: int
+    start: NotRequired[int]
+    step: NotRequired[int]
+
+
+class AtmTimeSeriesMeasurement(TypedDict):
+    """
+    JSON object describing time series measurement.
+
+    Time series measurement is a named value-timestamp pair which expresses some
+    property that can be dynamically changing (like file size, network speed, etc.).
+    Such measurements can be aggregated within time series stores and
+    serve as a data source for GUI charts.
+    """
+
+    tsName: str
+    timestamp: int
+    value: float
+
+
+class AtmException(TypedDict):
+    """
+    The exception envelope -- a failure reported on the wire as `{"exception": ...}`.
+
+    One shape, used at two levels:
+
+    * **per-job** -- returned in a handler's results list (in place of a result) to fail a
+      single job without failing the whole batch; `run()` passes it through.
+    * **whole-batch** -- returned by `run()` as the entire response (replacing
+      `resultsBatch`) when the batch fails before producing per-job results -- a malformed
+      request, a failed Oneclient mount, or a batch-level handler exception.
+    """
+
+    exception: float | str | AtmObject

onedata_lambda_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.5
+Name: onedata-lambda-sdk
+Version: 1.0.0
+Summary: SDK for writing Onedata Automation lambdas
+Project-URL: Homepage, https://onedata.org
+Author: Bartosz Walkowicz
+License: MIT License
+        ===========
+        
+            Copyright (C) 2022: Onedata (onedata.org)
+        
+            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.
+License-File: LICENSE.txt
+Keywords: automation,lambda,onedata,openfaas
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: requests>=2.32
+Description-Content-Type: text/markdown
+
+# onedata-lambda-sdk
+
+The Python SDK for writing **Onedata Automation lambdas** — the containerized
+operations that run as job executors in automation workflows. You write one
+handler function; the SDK turns the raw OpenFaaS request into typed jobs, runs
+your handler, streams its results, sends the mandatory first heartbeat and keeps
+the batch alive while it streams, and shapes the response the provider expects.
+
+```python
+from onedata_lambda_sdk import Job, JobContext, per_job
+
+@per_job(max_workers=10)
+def handle(job: Job[dict], ctx: JobContext[dict]) -> dict:
+    return {"result": process(job.args)}
+```
+
+## Documentation
+
+The full authoring documentation lives in [`docs/`](docs/):
+
+- **[SDK overview](docs/_overview.md)** — the three-layer model (base image →
+  SDK → handler) and how a job batch flows.
+- **Guides** — [writing a handler](docs/guides/writing-a-handler.md),
+  [a single-lambda repo](docs/guides/single-lambda-repo.md),
+  [several lambdas in a uv workspace](docs/guides/shared-code-uv-workspace.md),
+  [developing against a vendored SDK wheel](docs/guides/local-sdk-vendored-wheel.md),
+  [testing](docs/guides/testing-a-lambda.md),
+  [streaming logs and stats](docs/guides/streaming-logs-and-stats.md), and
+  [file access](docs/guides/file-access.md).
+- **[Runtime internals](docs/internals/runtime-and-lifecycle.md)** — for SDK
+  maintainers.
+
+The platform-side contract this SDK implements — how Oneprovider invokes a
+lambda, the I/O and relay methods, heartbeats — is in the internal developer
+documentation under `docs/automation/internals/lambda/` in
+`onedata-dev-documentation`.
+
+## Installation
+
+Requires Python 3.12 or newer.
+
+```bash
+pip install onedata-lambda-sdk
+```
+
+## Development
+
+```bash
+make sync     # create the .venv from the lockfile
+make check    # lint (ruff format-check + ruff check + mypy) + tests
+make test     # pytest with coverage
+```
+
+Run `make help` for the full target list.
+
+## Compatibility
+
+`onedata-lambda-sdk` targets the **v3 lambda model** (`run` / `@per_job` /
+`Job` / `JobContext`) and requires Oneprovider `21.02.5` or newer. A v3 lambda
+builds on the `onedata/lambda-base-slim:v3` base image — see
+[Lambda generations](docs/_overview.md#lambda-generations-v2-and-v3).

onedata_lambda_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+onedata_lambda_sdk/__init__.py,sha256=oRrig3MXT4dY8CEkPGWcuk1X9KqDGbpke7SEMV-Infc,1603
+onedata_lambda_sdk/_wire.py,sha256=qllskLbtVbdvnDZrVn0gekxSr1HiHv6KvuoLvxSKKm8,3566
+onedata_lambda_sdk/job.py,sha256=AimjlFTewBh5pcxe6Pt4aQHGUdcAQzuhEwxL5in9sTc,4528
+onedata_lambda_sdk/logging.py,sha256=Ar4Knkz7930cQTrMRB8G0AWypbAulRfJ_x6UrZ1ql2Q,3057
+onedata_lambda_sdk/oneclient.py,sha256=oK0jqM1-FOzlklF6SzZA95Uv9OZoBam588m7v01PWV8,1774
+onedata_lambda_sdk/perjob.py,sha256=-u_sbbllPm7B5hDwwVsO-OR8B_R4tDrUBl8NFPDPAE8,4991
+onedata_lambda_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onedata_lambda_sdk/runtime.py,sha256=K-PsbUenOJLny37gPTgbxI6VzPnxCzTBiMegGrT5HyU,15863
+onedata_lambda_sdk/stats.py,sha256=7gEDRInQv3Eq_PPahxNX244gAD4g5UL0VpILYb9JmsI,1567
+onedata_lambda_sdk/streaming.py,sha256=tgeOTF6bJ4HThOb92kVcLz41k9gAwBlScGAdI_C-lQI,5461
+onedata_lambda_sdk/testing.py,sha256=3o59sAMmZiBH-fs0GYd5rqGjaOWCJmggA71QbtmxvSM,11648
+onedata_lambda_sdk/types.py,sha256=7YPT3-O4A2GQ5--9-amY2scWB2cKL9_i-YbKRLL4Z8Y,5508
+onedata_lambda_sdk-1.0.0.dist-info/METADATA,sha256=AEDfBd-DXfAWVB3MAadQxLklt2BLqRmHijclmnNyOaQ,4229
+onedata_lambda_sdk-1.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+onedata_lambda_sdk-1.0.0.dist-info/licenses/LICENSE.txt,sha256=sNMlunt8MCfOBHX09_CXxyc1k_O9rA7NhlDfECkp4Es,1163
+onedata_lambda_sdk-1.0.0.dist-info/RECORD,,

onedata_lambda_sdk-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

onedata_lambda_sdk-1.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,24 @@
+MIT License
+===========
+
+    Copyright (C) 2022: Onedata (onedata.org)
+
+    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.