nori-rel 0.3.0__tar.gz

nori_rel-0.3.0/ATTRIBUTION.md

@@ -0,0 +1,42 @@
+# Attribution
+
+Original Synthefy code in Nori-Rel is distributed under the [MIT License](LICENSE).
+Third-party code retains its own license. The project license does not grant
+rights to third-party model weights, datasets, or hosted services.
+
+## PQL grammar and generated parser
+
+The PQL grammar derives from the NVIDIA Kumo Relational Client at commit
+`9fcdc8a111813e67787ce143fa0fdf5871d6d8de`:
+
+- Source: <https://github.com/kumo-ai/kumo-relational-client>
+- Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES.
+- License: Apache-2.0.
+- Unmodified grammar, license, notice, and provenance:
+  [`src/nori_rel/pql/_vendor/kumo/`](src/nori_rel/pql/_vendor/kumo/).
+- Modified grammar: [`src/nori_rel/pql/grammar/PQLGrammar.g4`](src/nori_rel/pql/grammar/PQLGrammar.g4).
+- Derived parser: [`src/nori_rel/pql/_generated/`](src/nori_rel/pql/_generated/).
+
+The modified grammar and generated parser retain this Apache-2.0 notice.
+The pinned upstream license and notice are included unchanged. The upstream
+notice covers its full distribution; it does not imply that Nori-Rel ships every
+component mentioned there. Parser generation instructions and source checksums
+are in the vendored `SOURCE.md`.
+
+## Installed dependencies
+
+[FastDFS](https://github.com/HKUSHXLab/fastdfs) supplies the supported relational
+feature implementation under Apache-2.0. It uses
+[Featuretools](https://github.com/alteryx/featuretools), copyright Feature Labs,
+Inc., under BSD-3-Clause. These libraries are installed as dependencies and are
+not vendored in Nori-Rel. ANTLR's Python runtime is separately installed under
+BSD-3-Clause. Other dependencies retain the terms in their distributions.
+
+The local Nori runtime and downloaded model artifacts are separately distributed.
+Review the selected model's license and model card before redistributing weights.
+
+## Examples and research
+
+The examples on `main` generate synthetic data; they do not redistribute a
+research dataset. Research code, attribution, methods, and results are maintained
+privately and are outside the supported release package.

nori_rel-0.3.0/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 0.3.0 — 2026-10-14
+
+Initial public database-client release.
+
+- Focus the distribution on PQL, FastDFS, PostgreSQL, Snowflake, Databricks,
+  local/hosted inference, pipeline export/reload, and prediction lifecycle.
+- Exclude research adapters, experimental feature search, benchmarks, notebooks,
+  their extras, and the research CLI from the supported distribution.
+- Add an independent `local` extra, public license/attribution, synthetic
+  examples, contribution/security guidance, and a documented support contract.
+- Validate saved model settings when reusing a pipeline predictor.
+- Add isolated package/connector checks, release certification, and protected
+  Trusted Publishing workflows using the tested distribution artifacts.
+
+Migration: use `query=` PQL and `features="fastdfs"`. Research feature names,
+agent programs, and research pipeline variants are outside the supported package.
+Install `nori-rel[<connector>,local]` for local inference (`database` is the
+PostgreSQL extra). The old research `nori-rel` command is no longer installed.
+
+Dependency findings and their expiring, version-specific
+assessments are documented in [the security review](docs/dependency-security.md).

nori_rel-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Synthefy
+
+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.

nori_rel-0.3.0/NOTICE

@@ -0,0 +1,19 @@
+Nori-Rel
+Copyright (c) 2026 Synthefy
+
+Original Synthefy code is licensed under the MIT License in LICENSE.
+Third-party components retain their own licenses and notices.
+
+The PQL grammar, its Synthefy modifications, and the generated parser derive
+from the NVIDIA Kumo Relational Client and are subject to Apache-2.0:
+
+Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES.
+
+The unmodified upstream license, notice, grammar, and provenance are included
+under src/nori_rel/pql/_vendor/kumo/. Synthefy's grammar modifications are
+identified in src/nori_rel/pql/grammar/PQLGrammar.g4; the generated parser
+headers identify this derivation. See ATTRIBUTION.md for source details.
+
+The upstream NOTICE describes components of the full upstream distribution.
+Its inclusion preserves that notice; Nori-Rel vendors only the PQL grammar
+and the accompanying license/provenance files, and ships its derived parser.

nori_rel-0.3.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: nori-rel
+Version: 0.3.0
+Summary: Relational database prediction with Nori
+Author: Synthefy
+License-Expression: MIT AND Apache-2.0
+License-File: ATTRIBUTION.md
+License-File: LICENSE
+License-File: NOTICE
+License-File: src/nori_rel/pql/_vendor/kumo/LICENSE
+License-File: src/nori_rel/pql/_vendor/kumo/NOTICE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Dist: antlr4-python3-runtime==4.13.2
+Requires-Dist: numpy>=2.0
+Requires-Dist: pandas>=2.3.3,<3.0
+Requires-Dist: pydantic>=2.10,<3
+Requires-Dist: boto3>=1.34,<2 ; extra == 'database'
+Requires-Dist: fastdfs>=1.1,<2 ; extra == 'database'
+Requires-Dist: psycopg[binary]>=3.2,<4 ; extra == 'database'
+Requires-Dist: sqlalchemy>=2.0,<3 ; extra == 'database'
+Requires-Dist: synthefy>=7.2.0,<8 ; extra == 'database'
+Requires-Dist: urllib3>=2.8,<3 ; extra == 'database'
+Requires-Dist: boto3>=1.34,<2 ; extra == 'databricks'
+Requires-Dist: databricks-sdk>=0.151,<1 ; extra == 'databricks'
+Requires-Dist: databricks-sql-connector>=4.6,<5 ; extra == 'databricks'
+Requires-Dist: fastdfs>=1.1,<2 ; extra == 'databricks'
+Requires-Dist: sqlalchemy>=2.0,<3 ; extra == 'databricks'
+Requires-Dist: synthefy>=7.2.0,<8 ; extra == 'databricks'
+Requires-Dist: urllib3>=2.8,<3 ; extra == 'databricks'
+Requires-Dist: synthefy-nori==0.20.1 ; extra == 'local'
+Requires-Dist: fsspec>=2026.6.0 ; extra == 'local'
+Requires-Dist: boto3>=1.34,<2 ; extra == 'snowflake'
+Requires-Dist: fastdfs>=1.1,<2 ; extra == 'snowflake'
+Requires-Dist: snowflake-connector-python>=4.8,<5 ; extra == 'snowflake'
+Requires-Dist: sqlalchemy>=2.0,<3 ; extra == 'snowflake'
+Requires-Dist: synthefy>=7.2.0,<8 ; extra == 'snowflake'
+Requires-Dist: urllib3>=2.8,<3 ; extra == 'snowflake'
+Requires-Python: >=3.11, <3.13
+Project-URL: Repository, https://github.com/Synthefy/nori-rel
+Project-URL: Issues, https://github.com/Synthefy/nori-rel/issues
+Project-URL: Changelog, https://github.com/Synthefy/nori-rel/blob/main/CHANGELOG.md
+Provides-Extra: database
+Provides-Extra: databricks
+Provides-Extra: local
+Provides-Extra: snowflake
+Description-Content-Type: text/markdown
+
+# Nori-Rel
+
+Predict from relational databases with [Nori](https://docs.synthefy.com/nori).
+Nori-Rel reads a bounded database snapshot, constructs historical targets and
+FastDFS features, and runs local or hosted inference through one Python client.
+
+The supported package covers PostgreSQL, Snowflake standard tables, and
+Databricks Unity Catalog Delta tables. Releases come from reviewed commits on
+`main`.
+
+Review the [support contract](docs/support.md) and
+[dependency security assessment](docs/dependency-security.md) before deployment.
+The assessment includes scoped, expiring exceptions for upstream dependencies.
+
+## Install
+
+Python 3.11 and 3.12 are supported. Install your connector and, for the default
+local inference mode, the model runtime:
+
+```bash
+python -m pip install "nori-rel[database,local]"
+# Other connectors:
+python -m pip install "nori-rel[snowflake,local]"
+python -m pip install "nori-rel[databricks,local]"
+```
+
+For hosted inference, omit `local` and set `SYNTHEFY_NORI_API_KEY` privately.
+A hosted installation does not require the local model runtime or model weights.
+See [supported capabilities](docs/support.md) for platform and target limits.
+
+## Predict customer spend
+
+This example expects existing `users(user_id, created_at)` and
+`orders(order_id, user_id, event_time, amount)` tables with declared primary and
+foreign keys. Set `DATABASE_URL` to a TLS-enabled PostgreSQL connection string.
+Use [the synthetic example](examples/README.md) for a complete disposable dataset.
+
+```python
+from datetime import UTC, datetime
+
+from nori_rel import EnvironmentCredential, NoriRelClient
+
+with NoriRelClient() as client:
+    source = client.connect(
+        engine="postgresql",
+        credential=EnvironmentCredential(variable="DATABASE_URL"),
+        tables=["users", "orders"],
+        time_columns={"orders": "event_time"},
+    )
+    details = client.predict(
+        source=source,
+        query="PREDICT SUM(orders.amount,0,30,days) FOR EACH users.user_id",
+        anchor_times=[datetime(2026, 1, 1, tzinfo=UTC)],
+        anchor_time=datetime(2026, 3, 1, tzinfo=UTC),
+        observed_through=datetime(2026, 3, 1, tzinfo=UTC),
+        entity_created_at="created_at",
+        return_details=True,
+    )
+    predictions = details.predictions
+    print(predictions[["entity_id", "prediction"]])
+```
+
+The query predicts each user's total order amount over the next 30 days.
+`anchor_times` supplies historical examples; `anchor_time` is the scoring time.
+`observed_through` is your verified data-completeness watermark, not an estimate
+of completeness from the latest event. Use dates appropriate to your data and
+at least 32 usable historical rows. Register every event table's timestamp;
+other entity attributes must be immutable or valid at every requested anchor.
+See [PQL and time semantics](docs/pql.md).
+
+The default mode runs Nori in your process. The first local prediction downloads
+model weights; subsequent predictions can use the populated cache offline.
+Use `NoriRelClient(mode="hosted")` to send the generated context/query feature
+matrices and labels to hosted Nori. Database connections, credentials, and raw
+source tables stay in the caller's process. Generated features can still contain
+sensitive information derived from those tables.
+
+## Save and reload
+
+Request prediction details to obtain a pipeline, then reconnect when using it:
+
+```python
+from nori_rel import NoriRelPipeline
+
+if details.pipeline is None:
+    raise RuntimeError("This prediction cannot be exported as a pipeline")
+details.pipeline.save("customer_spend.json")
+
+pipeline = NoriRelPipeline.load("customer_spend.json")
+with NoriRelClient() as client:
+    source = client.connect(
+        engine="postgresql",
+        credential=EnvironmentCredential(variable="DATABASE_URL"),
+        tables=["users", "orders"],
+        time_columns={"orders": "event_time"},
+    )
+    predictions = client.predict(
+        source=source,
+        pipeline=pipeline,
+        as_of=datetime(2026, 4, 1, tzinfo=UTC),
+        observed_through=datetime(2026, 4, 1, tzinfo=UTC),
+    )
+```
+
+A pipeline stores the task, feature recipe, schema contract, context policy, and
+model settings. Each replay reads fresh rows. It contains no credentials,
+source rows, or model weights. See [pipeline export](docs/pipeline-export.md)
+and the runnable [save/reload example](examples/pipeline_reload.py).
+
+## Operations and safety boundaries
+
+Use the client as a context manager to close connection pools. PostgreSQL uses
+TLS and read-only transactions; warehouse connectors use pinned reads and require
+a dedicated identity without write privileges. Warehouse capabilities and
+snapshot guarantees are documented in the [connector guide](docs/warehouse-connectors.md).
+
+`RelationalLimits` bounds tables, rows, snapshot memory, feature size, and SQL
+statement time. Exceeding an extraction limit raises an error. These limits do
+not cap total warehouse billing or the process's total memory. See
+[configuration and errors](docs/api.md) and [progress/cancellation](docs/run-control.md).
+
+## Development and licensing
+
+See the [public API inventory](docs/public-api.md),
+[CONTRIBUTING.md](CONTRIBUTING.md), [SECURITY.md](SECURITY.md), and
+[RELEASING.md](RELEASING.md). Public release changes are recorded in
+[CHANGELOG.md](CHANGELOG.md).
+
+Original Synthefy code is [MIT-licensed](LICENSE). The vendored PQL grammar and
+derived parser retain Apache-2.0 licensing. Dependencies, downloaded model weights,
+and external datasets have their own terms; see [ATTRIBUTION.md](ATTRIBUTION.md).

nori_rel-0.3.0/README.md

@@ -0,0 +1,131 @@
+# Nori-Rel
+
+Predict from relational databases with [Nori](https://docs.synthefy.com/nori).
+Nori-Rel reads a bounded database snapshot, constructs historical targets and
+FastDFS features, and runs local or hosted inference through one Python client.
+
+The supported package covers PostgreSQL, Snowflake standard tables, and
+Databricks Unity Catalog Delta tables. Releases come from reviewed commits on
+`main`.
+
+Review the [support contract](docs/support.md) and
+[dependency security assessment](docs/dependency-security.md) before deployment.
+The assessment includes scoped, expiring exceptions for upstream dependencies.
+
+## Install
+
+Python 3.11 and 3.12 are supported. Install your connector and, for the default
+local inference mode, the model runtime:
+
+```bash
+python -m pip install "nori-rel[database,local]"
+# Other connectors:
+python -m pip install "nori-rel[snowflake,local]"
+python -m pip install "nori-rel[databricks,local]"
+```
+
+For hosted inference, omit `local` and set `SYNTHEFY_NORI_API_KEY` privately.
+A hosted installation does not require the local model runtime or model weights.
+See [supported capabilities](docs/support.md) for platform and target limits.
+
+## Predict customer spend
+
+This example expects existing `users(user_id, created_at)` and
+`orders(order_id, user_id, event_time, amount)` tables with declared primary and
+foreign keys. Set `DATABASE_URL` to a TLS-enabled PostgreSQL connection string.
+Use [the synthetic example](examples/README.md) for a complete disposable dataset.
+
+```python
+from datetime import UTC, datetime
+
+from nori_rel import EnvironmentCredential, NoriRelClient
+
+with NoriRelClient() as client:
+    source = client.connect(
+        engine="postgresql",
+        credential=EnvironmentCredential(variable="DATABASE_URL"),
+        tables=["users", "orders"],
+        time_columns={"orders": "event_time"},
+    )
+    details = client.predict(
+        source=source,
+        query="PREDICT SUM(orders.amount,0,30,days) FOR EACH users.user_id",
+        anchor_times=[datetime(2026, 1, 1, tzinfo=UTC)],
+        anchor_time=datetime(2026, 3, 1, tzinfo=UTC),
+        observed_through=datetime(2026, 3, 1, tzinfo=UTC),
+        entity_created_at="created_at",
+        return_details=True,
+    )
+    predictions = details.predictions
+    print(predictions[["entity_id", "prediction"]])
+```
+
+The query predicts each user's total order amount over the next 30 days.
+`anchor_times` supplies historical examples; `anchor_time` is the scoring time.
+`observed_through` is your verified data-completeness watermark, not an estimate
+of completeness from the latest event. Use dates appropriate to your data and
+at least 32 usable historical rows. Register every event table's timestamp;
+other entity attributes must be immutable or valid at every requested anchor.
+See [PQL and time semantics](docs/pql.md).
+
+The default mode runs Nori in your process. The first local prediction downloads
+model weights; subsequent predictions can use the populated cache offline.
+Use `NoriRelClient(mode="hosted")` to send the generated context/query feature
+matrices and labels to hosted Nori. Database connections, credentials, and raw
+source tables stay in the caller's process. Generated features can still contain
+sensitive information derived from those tables.
+
+## Save and reload
+
+Request prediction details to obtain a pipeline, then reconnect when using it:
+
+```python
+from nori_rel import NoriRelPipeline
+
+if details.pipeline is None:
+    raise RuntimeError("This prediction cannot be exported as a pipeline")
+details.pipeline.save("customer_spend.json")
+
+pipeline = NoriRelPipeline.load("customer_spend.json")
+with NoriRelClient() as client:
+    source = client.connect(
+        engine="postgresql",
+        credential=EnvironmentCredential(variable="DATABASE_URL"),
+        tables=["users", "orders"],
+        time_columns={"orders": "event_time"},
+    )
+    predictions = client.predict(
+        source=source,
+        pipeline=pipeline,
+        as_of=datetime(2026, 4, 1, tzinfo=UTC),
+        observed_through=datetime(2026, 4, 1, tzinfo=UTC),
+    )
+```
+
+A pipeline stores the task, feature recipe, schema contract, context policy, and
+model settings. Each replay reads fresh rows. It contains no credentials,
+source rows, or model weights. See [pipeline export](docs/pipeline-export.md)
+and the runnable [save/reload example](examples/pipeline_reload.py).
+
+## Operations and safety boundaries
+
+Use the client as a context manager to close connection pools. PostgreSQL uses
+TLS and read-only transactions; warehouse connectors use pinned reads and require
+a dedicated identity without write privileges. Warehouse capabilities and
+snapshot guarantees are documented in the [connector guide](docs/warehouse-connectors.md).
+
+`RelationalLimits` bounds tables, rows, snapshot memory, feature size, and SQL
+statement time. Exceeding an extraction limit raises an error. These limits do
+not cap total warehouse billing or the process's total memory. See
+[configuration and errors](docs/api.md) and [progress/cancellation](docs/run-control.md).
+
+## Development and licensing
+
+See the [public API inventory](docs/public-api.md),
+[CONTRIBUTING.md](CONTRIBUTING.md), [SECURITY.md](SECURITY.md), and
+[RELEASING.md](RELEASING.md). Public release changes are recorded in
+[CHANGELOG.md](CHANGELOG.md).
+
+Original Synthefy code is [MIT-licensed](LICENSE). The vendored PQL grammar and
+derived parser retain Apache-2.0 licensing. Dependencies, downloaded model weights,
+and external datasets have their own terms; see [ATTRIBUTION.md](ATTRIBUTION.md).

nori_rel-0.3.0/docs/api.md

@@ -0,0 +1,100 @@
+# Client configuration and errors
+
+The public entry point is `nori_rel.NoriRelClient`. It owns connection pools and
+prediction runs; use `with NoriRelClient(...) as client:` or call `close()`.
+Closing is idempotent. A closed client cannot be reused. Create a new client to
+pick up rotated database credentials.
+
+## Inference settings
+
+| Setting | Default and behavior |
+| --- | --- |
+| `mode` | `"local"`; `"hosted"` opts into the hosted service. |
+| `model` | `"nori-30m"`; local supports `nori-6m`, `nori-30m`, and `nori-100m`. |
+| `api_key` | Hosted mode uses this value or `SYNTHEFY_NORI_API_KEY`. |
+| `device` | Local only; automatic CUDA, then MPS, then CPU. An explicit PyTorch device can be supplied. |
+| `features` | `"fastdfs"`, the supported built-in feature backend. |
+| `timeout` | 300 seconds for inference transport configuration. |
+| `max_retries` | 2 for hosted transport retries. |
+| `limits` | `RelationalLimits()` for extraction/context ceilings. |
+
+`timeout` is not a hard deadline for the complete relational workflow.
+`run.result(timeout=...)` bounds the caller's wait and leaves the run active;
+see [run control](run-control.md).
+
+The optional local runtime is pinned independently of the lightweight Synthefy
+SDK. Initial prediction downloads the selected weights to the Hugging Face
+cache. Populate that cache first to run with `HF_HUB_OFFLINE=1`. Missing or
+corrupted required weights cause an actionable failure; local mode never falls
+back to a hosted call. Hardware, runtime, and source changes can affect numerical
+results. Pipeline hashes detect specific source/model changes, not arbitrary
+numerical nondeterminism.
+
+## Connections
+
+`connect()` returns a `Database` handle. Provide `engine` and exactly one of
+`database_url` or `credential`. Credential references are:
+
+- `EnvironmentCredential(variable="DATABASE_URL")` for a PostgreSQL URL, or
+  a variable holding warehouse authentication JSON.
+- `AwsSecret(secret_id="your-secret-name", region_name="us-west-2")` for AWS
+  Secrets Manager. PostgreSQL accepts a URL or standard RDS JSON fields.
+- `DatabaseUrl(value=...)`, primarily for direct PostgreSQL URL use.
+
+Each connector extra includes AWS credential support. An RDS or Aurora PostgreSQL
+endpoint still uses `engine="postgresql"`; MySQL is unsupported.
+
+Use `schema_name`, a `tables` allowlist, and `time_columns` mappings. Warehouses
+require a typed `connection` object and an explicit schema. `primary_keys` and
+`foreign_keys` supply relationships when warehouse metadata lacks them.
+`client.test_connection(source)` checks connectivity, and `client.discover(source)`
+returns the schema and connector capabilities. See [warehouse setup](warehouse-connectors.md).
+
+## Resource limits
+
+```python
+from nori_rel import NoriRelClient, RelationalLimits
+
+client = NoriRelClient(
+    limits=RelationalLimits(
+        max_rows_per_table=100_000,
+        max_total_rows=300_000,
+        max_snapshot_bytes=500_000_000,
+        statement_timeout_ms=60_000,
+    )
+)
+# Connect, predict, and close the client when finished.
+```
+
+| Limit | Default |
+| --- | ---: |
+| Tables | 32 |
+| Rows per table | 1,000,000 |
+| Total snapshot rows | 3,000,000 |
+| Snapshot bytes | 4,000,000,000 |
+| SQL statement timeout | 300,000 ms |
+| Minimum training rows | 32 |
+| Maximum context rows | 60,000 |
+| Feature elements | 3,000,000 |
+| Features | 512 |
+
+The per-request `max_context_rows` defaults to 5,000 and remains subject to the
+resource ceilings. Snapshot limits constrain extracted data; feature building
+and model inference can allocate additional memory. SQL timeouts and row limits
+do not guarantee a fixed warehouse scan cost. Exceeding an extraction limit
+fails the operation instead of silently truncating source data.
+
+## Errors and compatibility
+
+Invalid arguments raise `ValueError` or typed validation errors. Connector
+failures raise `nori_rel.connectors.errors.ConnectorError`; extraction limits raise its
+`SnapshotLimitError` subclass. Prediction runs expose `PredictionCancelled`,
+`PredictionFailed`, and `RunTimeout`. Saved-pipeline incompatibilities raise a
+`PipelineError` subclass, described in [pipeline export](pipeline-export.md).
+Inspect error types and messages rather than matching full exception strings.
+
+The old `entity`/`target` aggregate request form is a deprecated compatibility
+bridge and emits `FutureWarning`. Use `query=` PQL for new code. Direct/NEXT
+legacy targets and explicit relationship-path prediction are retired. Research
+feature engines and their saved pipeline variants are outside the public client
+contract and are not included in this package.