tensorplate-python 0.1.3__py3-none-any.whl

tensorplate/tensors.py

@@ -0,0 +1,250 @@
+"""Tensor value objects and v0.1 serving-envelope tensor marshalling.
+
+Tensors travel over the wire as base64-encoded raw bytes plus a small
+metadata block (``dtype``, ``shape``, ``layout``, ``byte_offset``,
+``byte_size``). These value objects own that marshalling so the client
+and the vision helpers share one representation. ``numpy`` is an optional
+dependency: array access imports it lazily and fails with a clear message
+when it is absent.
+"""
+
+from __future__ import annotations
+
+import base64
+import math
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Literal
+
+from tensorplate.errors import ProtocolError
+
+if TYPE_CHECKING:
+    import numpy as np
+
+
+class DType(str, Enum):
+    """Supported v0.1 envelope tensor dtypes."""
+
+    FLOAT32 = "float32"
+    FLOAT16 = "float16"
+    BFLOAT16 = "bfloat16"
+    INT64 = "int64"
+    INT32 = "int32"
+    INT16 = "int16"
+    INT8 = "int8"
+    UINT8 = "uint8"
+    BOOL = "bool"
+
+
+class Layout(str, Enum):
+    """Memory layout of the raw tensor bytes."""
+
+    ROW_MAJOR = "row_major"
+    COL_MAJOR = "col_major"
+
+
+#: Bytes per element for each dtype.
+_ITEMSIZE: dict[DType, int] = {
+    DType.FLOAT32: 4,
+    DType.FLOAT16: 2,
+    DType.BFLOAT16: 2,
+    DType.INT64: 8,
+    DType.INT32: 4,
+    DType.INT16: 2,
+    DType.INT8: 1,
+    DType.UINT8: 1,
+    DType.BOOL: 1,
+}
+
+#: dtypes with a native numpy mapping. ``bfloat16`` is intentionally
+#: absent: numpy has no native bfloat16, so array access for it raises.
+_NUMPY_NAME: dict[DType, str] = {
+    DType.FLOAT32: "float32",
+    DType.FLOAT16: "float16",
+    DType.INT64: "int64",
+    DType.INT32: "int32",
+    DType.INT16: "int16",
+    DType.INT8: "int8",
+    DType.UINT8: "uint8",
+    DType.BOOL: "bool",
+}
+
+_NUMPY_NAME_TO_DTYPE: dict[str, DType] = {name: dt for dt, name in _NUMPY_NAME.items()}
+
+
+def itemsize(dtype: DType) -> int:
+    """Return the number of bytes per element for ``dtype``."""
+    return _ITEMSIZE[dtype]
+
+
+@dataclass(frozen=True)
+class TensorInput:
+    """A single named input tensor ready to marshal into the v0.1 envelope."""
+
+    name: str
+    dtype: DType
+    shape: tuple[int, ...]
+    data: bytes
+    layout: Layout = Layout.ROW_MAJOR
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("tensor input name must be non-empty")
+        if not self.shape:
+            raise ValueError(f"tensor input {self.name!r} must have at least one dimension")
+        if any(dim < 1 for dim in self.shape):
+            raise ValueError(
+                f"tensor input {self.name!r} has a non-positive dimension: {self.shape}"
+            )
+        expected = _ITEMSIZE[self.dtype] * math.prod(self.shape)
+        if len(self.data) != expected:
+            raise ValueError(
+                f"tensor input {self.name!r}: data is {len(self.data)} bytes, expected {expected} "
+                f"for dtype {self.dtype.value} shape {self.shape}"
+            )
+
+    def to_named_input(self) -> dict[str, object]:
+        """Serialize to a v0.1 ``NamedInput`` envelope object."""
+        return {
+            "name": self.name,
+            "tensor": {
+                "dtype": self.dtype.value,
+                "layout": self.layout.value,
+                "shape": list(self.shape),
+                "byte_offset": 0,
+                "byte_size": len(self.data),
+            },
+            "payload_b64": base64.b64encode(self.data).decode("ascii"),
+        }
+
+    @classmethod
+    def from_numpy(
+        cls,
+        name: str,
+        array: np.ndarray,
+        *,
+        dtype: DType | None = None,
+        layout: Layout = Layout.ROW_MAJOR,
+    ) -> TensorInput:
+        """Build a ``TensorInput`` from a numpy array (numpy required)."""
+        resolved = dtype if dtype is not None else _NUMPY_NAME_TO_DTYPE.get(str(array.dtype))
+        if resolved is None:
+            raise ValueError(
+                f"numpy dtype {array.dtype!r} has no v0.1 envelope mapping; "
+                "pass `dtype=` explicitly"
+            )
+        order: Literal["C", "F"] = "C" if layout is Layout.ROW_MAJOR else "F"
+        data = array.astype(_NUMPY_NAME[resolved], copy=False).tobytes(order=order)
+        return cls(
+            name=name,
+            dtype=resolved,
+            shape=tuple(int(dim) for dim in array.shape),
+            data=data,
+            layout=layout,
+        )
+
+
+@dataclass(frozen=True)
+class TensorOutput:
+    """A single named output tensor parsed from a v0.1 success envelope."""
+
+    name: str
+    dtype: DType
+    shape: tuple[int, ...]
+    data: bytes
+    layout: Layout = Layout.ROW_MAJOR
+    semantic_tag: str | None = None
+
+    @classmethod
+    def from_named_output(cls, obj: object) -> TensorOutput:
+        """Parse a v0.1 ``NamedOutput`` envelope object."""
+        if not isinstance(obj, dict):
+            raise ProtocolError("serving output entry is not a JSON object")
+        name = obj.get("name")
+        if not isinstance(name, str) or not name:
+            raise ProtocolError("serving output is missing a non-empty 'name'")
+        tensor = obj.get("tensor")
+        if not isinstance(tensor, dict):
+            raise ProtocolError(f"serving output {name!r} is missing its 'tensor' metadata")
+        dtype_value = tensor.get("dtype")
+        try:
+            dtype = DType(dtype_value)
+        except ValueError as exc:
+            raise ProtocolError(
+                f"serving output {name!r} has unknown dtype {dtype_value!r}"
+            ) from exc
+        layout_value = tensor.get("layout", Layout.ROW_MAJOR.value)
+        try:
+            layout = Layout(layout_value)
+        except ValueError as exc:
+            raise ProtocolError(
+                f"serving output {name!r} has unknown layout {layout_value!r}"
+            ) from exc
+        shape_raw = tensor.get("shape")
+        if (
+            not isinstance(shape_raw, list)
+            or not shape_raw
+            or not all(
+                isinstance(dim, int) and not isinstance(dim, bool) and dim >= 1 for dim in shape_raw
+            )
+        ):
+            raise ProtocolError(f"serving output {name!r} has an invalid 'shape'")
+        shape = tuple(int(dim) for dim in shape_raw)
+        expected_size = _ITEMSIZE[dtype] * math.prod(shape)
+        payload_b64 = obj.get("payload_b64")
+        if not isinstance(payload_b64, str):
+            raise ProtocolError(f"serving output {name!r} is missing 'payload_b64'")
+        try:
+            raw = base64.b64decode(payload_b64, validate=True)
+        except ValueError as exc:
+            raise ProtocolError(f"serving output {name!r} has an invalid base64 payload") from exc
+        offset_obj = tensor.get("byte_offset", 0)
+        if not isinstance(offset_obj, int) or isinstance(offset_obj, bool) or offset_obj < 0:
+            raise ProtocolError(f"serving output {name!r} has an invalid 'byte_offset'")
+        offset = offset_obj
+        if "byte_size" in tensor:
+            size_obj = tensor.get("byte_size")
+            if not isinstance(size_obj, int) or isinstance(size_obj, bool) or size_obj < 0:
+                raise ProtocolError(f"serving output {name!r} has an invalid 'byte_size'")
+            size = expected_size if size_obj == 0 else size_obj
+        else:
+            size = expected_size
+        if size < expected_size:
+            raise ProtocolError(
+                f"serving output {name!r} byte_size is {size}, expected {expected_size} "
+                f"for dtype {dtype.value} shape {shape}"
+            )
+        end = offset + size
+        if len(raw) < end:
+            raise ProtocolError(f"serving output {name!r} payload is {len(raw)} bytes, need {end}")
+        data = raw[offset : offset + expected_size]
+        semantic_tag = obj.get("semantic_tag")
+        return cls(
+            name=name,
+            dtype=dtype,
+            shape=shape,
+            data=data,
+            layout=layout,
+            semantic_tag=semantic_tag if isinstance(semantic_tag, str) else None,
+        )
+
+    def to_numpy(self) -> np.ndarray:
+        """Return the tensor as a numpy array (numpy required).
+
+        Raises ``ValueError`` for dtypes with no native numpy mapping
+        (``bfloat16``); use :attr:`data` for the raw bytes in that case.
+        """
+        numpy_name = _NUMPY_NAME.get(self.dtype)
+        if numpy_name is None:
+            raise ValueError(
+                f"dtype {self.dtype.value!r} has no native numpy mapping; read `.data` instead"
+            )
+        try:
+            import numpy
+        except ModuleNotFoundError as exc:  # pragma: no cover - exercised only without numpy
+            raise RuntimeError(
+                "tensor array access requires numpy; install `tensorplate-python[numpy]`"
+            ) from exc
+        array = numpy.frombuffer(self.data, dtype=numpy_name)
+        order: Literal["C", "F"] = "C" if self.layout is Layout.ROW_MAJOR else "F"
+        return array.reshape(self.shape, order=order)

tensorplate/vision.py

@@ -0,0 +1,121 @@
+"""High-level vision detection client built on the serving client."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import replace
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from tensorplate.client import DEFAULT_TIMEOUT_S
+from tensorplate.conventions import YOLO_V8_SINGLE_OUTPUT, detections
+from tensorplate.errors import ProtocolError
+from tensorplate.postprocess import Detection, decode_detections
+from tensorplate.preprocess import PreprocessConfig, preprocess
+from tensorplate.serving import InferResult, ServingClient
+from tensorplate.tensors import TensorOutput
+
+if TYPE_CHECKING:
+    import numpy as np
+
+_DETECTION_TAGS = frozenset({detections.boxes, detections.scores, detections.classes})
+_DEFAULT_INPUT_NAME = "images"
+
+
+class VisionClient:
+    """High-level object-detection client over a deployed detector.
+
+    Composes client-side preprocessing, ``ServingClient.infer``, and YOLO
+    postprocessing into a single :meth:`detect` call. Synchronous in
+    v0.1.3. Pass an existing :class:`ServingClient` via ``client``, or let
+    the constructor resolve one with the same precedence as the CLI.
+    """
+
+    def __init__(
+        self,
+        serving_url: str | None = None,
+        *,
+        profile: str | None = None,
+        config_path: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT_S,
+        discover: bool = True,
+        client: ServingClient | None = None,
+    ) -> None:
+        self._serving = client or ServingClient(
+            serving_url,
+            profile=profile,
+            config_path=config_path,
+            timeout=timeout,
+            discover=discover,
+        )
+
+    @property
+    def serving(self) -> ServingClient:
+        """The underlying serving client."""
+        return self._serving
+
+    def detect(
+        self,
+        image: str | bytes | Path | np.ndarray,
+        *,
+        endpoint: str,
+        input_name: str = _DEFAULT_INPUT_NAME,
+        output_name: str | None = None,
+        score_threshold: float = 0.25,
+        nms_threshold: float = 0.45,
+        labels: Sequence[str] | None = None,
+        transposed: bool = False,
+        contract: str = YOLO_V8_SINGLE_OUTPUT,
+        preprocess_config: PreprocessConfig | None = None,
+    ) -> list[Detection]:
+        """Detect objects in ``image`` using the deployed model at ``endpoint``.
+
+        Preprocesses the image, runs one synchronous inference, and decodes
+        the detector output into source-pixel :class:`Detection` results.
+        Requires the ``tensorplate-python[vision]`` extra. The detection
+        output tensor is chosen explicitly (``output_name``), or — for a
+        single-output response — automatically, or by a ``detections.*``
+        ``semantic_tag``; an ambiguous response fails clearly.
+        """
+        if preprocess_config is not None:
+            config = (
+                preprocess_config
+                if input_name == _DEFAULT_INPUT_NAME
+                else replace(preprocess_config, input_name=input_name)
+            )
+        else:
+            config = PreprocessConfig(input_name=input_name)
+        tensor, transform = preprocess(image, config)
+        result = self._serving.infer(endpoint, [tensor])
+        output = _select_detection_output(result, output_name)
+        return decode_detections(
+            output,
+            transform,
+            score_threshold=score_threshold,
+            nms_threshold=nms_threshold,
+            labels=labels,
+            transposed=transposed,
+            contract=contract,
+        )
+
+
+def _select_detection_output(result: InferResult, output_name: str | None) -> TensorOutput:
+    if output_name is not None:
+        for output in result.outputs:
+            if output.name == output_name:
+                return output
+        available = [output.name for output in result.outputs]
+        raise ProtocolError(
+            f"serving response has no output named {output_name!r}; available: {available}"
+        )
+    if len(result.outputs) == 1:
+        return result.outputs[0]
+    tagged = [output for output in result.outputs if output.semantic_tag in _DETECTION_TAGS]
+    if len(tagged) == 1:
+        return tagged[0]
+    available = [output.name for output in result.outputs]
+    raise ProtocolError(
+        f"serving response has {len(result.outputs)} outputs; pass output_name to choose the "
+        f"detection tensor (available: {available}), or tag exactly one output with a "
+        "detections.* semantic_tag"
+    )

tensorplate_python-0.1.3.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: tensorplate-python
+Version: 0.1.3
+Summary: First-party Python SDK for calling deployed TensorPlate detection and vision serving models.
+Author: TensorPlate Contributors
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/tensorplate/tensorplate
+Project-URL: Repository, https://github.com/tensorplate/tensorplate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.22; extra == "numpy"
+Provides-Extra: vision
+Requires-Dist: numpy>=1.22; extra == "vision"
+Requires-Dist: pillow>=9.1; extra == "vision"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# `sdk/python/`
+
+`tensorplate-python` — the first-party Python SDK for calling deployed
+TensorPlate detection and vision serving models over the v0.1 `/infer`
+HTTP envelope.
+
+The import package is `tensorplate`:
+
+```python
+import tensorplate
+```
+
+## Install
+
+```bash
+pip install tensorplate-python            # core client
+pip install "tensorplate-python[vision]"  # + numpy & Pillow for VisionClient.detect
+```
+
+The wheel + sdist are also attached to each signed GitHub Release for
+checksum-verified or air-gapped installs. See the
+[SDK quickstart](../../docs/sdk/python.md#install) for that flow and the
+`[numpy]` / `[vision]` extras.
+
+## Ownership
+
+- **Layer:** client / user space (no runtime or serving-worker code)
+- **Language:** Python (3.10+)
+- **Distribution:** `tensorplate-python` (PEP 621 `pyproject.toml`)
+- **Import package:** `tensorplate`
+
+## Documentation
+
+- [Quickstart and API reference](../../docs/sdk/python.md) —
+  `ServingClient`, `VisionClient`, `Detection`, tensors, and errors.
+- [Detection workflow](../../docs/sdk/detection.md) — preprocessing, the
+  `yolo_v8_single_output` contract, and postprocessing.
+- [Endpoint resolution](../../docs/sdk/endpoint-resolution.md) — CLI-parity
+  precedence and URL canonicalization.
+- [Examples](../../examples/vision_detection_sdk/) — single-image and
+  user-space camera samples.
+
+## Scope
+
+The SDK is a client-side library: it calls already-deployed models and
+does not change runtime serving. In-runtime camera/video ingest, a
+DeepStream sink, and a streaming session API are out of scope and are
+not provided here.
+
+## License
+
+Apache-2.0. See [`LICENSE`](LICENSE).

tensorplate_python-0.1.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+tensorplate/__init__.py,sha256=cPJYqsMBR-PjWtfqN1N1yA2alUrVv32RwaSSTPQ1UUs,1961
+tensorplate/client.py,sha256=SwgFZYnxXO1Ff3ruBSIAdCMzbyReGixlXOvjYK6Oj5M,10506
+tensorplate/conventions.py,sha256=rysRZVfesQ6vRLrlTxiWbRBK4zbazvv-9njmBVKdJJo,1109
+tensorplate/errors.py,sha256=oZSYgG1T8TtLaw4jFwW806KzfDzke_5GB6Omlkvx8Uw,2718
+tensorplate/postprocess.py,sha256=GusFErKCJdUERoDUDvdrPbMkt0wtEFkXL5R3_c5O_JA,5186
+tensorplate/preprocess.py,sha256=ItUWijW3jKzel3ESLhnjg5ag6BoNXQhytpa_2o08fKk,6019
+tensorplate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tensorplate/serving.py,sha256=d4OYe4JdcPFJWTwTzbi3xgbftFxgfSEHDiubc7C_eAc,10287
+tensorplate/tensors.py,sha256=KvI3zYkAfNuquBKb9xDT-Mt4W8HudMECt02aHbMKm6Y,8939
+tensorplate/vision.py,sha256=KwbVfPqtqdbIGSzEKqbkif9-KZj6U0zUZ81MrQDPPhw,4531
+tensorplate_python-0.1.3.dist-info/licenses/LICENSE,sha256=ZxVIDHiEBfOHLu3QJTeSSO8fYRNUlInHP9ESK3DZmEE,11389
+tensorplate_python-0.1.3.dist-info/METADATA,sha256=vS3F-CXLjd5BCrwYKRsUkzbzkyZZtNPp9d3Oy62JX3c,2905
+tensorplate_python-0.1.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tensorplate_python-0.1.3.dist-info/top_level.txt,sha256=FFVk-zeOOH6pSd9Hd9gzDD7WSJpbZ23RazVSCssIXnM,12
+tensorplate_python-0.1.3.dist-info/RECORD,,

tensorplate_python-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tensorplate_python-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,203 @@
+Copyright 2026 TensorPlate Inc
+
+                                 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.

tensorplate_python-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+tensorplate