vania-janet/multiturn-rag-retrieval-data huggingface dataset:
For more information about depreciation note, see [Schematics announcement](https://cloud.ibm.com/status/announcement?component=schematics).



Schematics depreciation note

 From date Deprecation notice 

 21 September 2022 Support for Python v3.6 in runtime-ansible-job is deprecated. Instead the runtime-ansible job image uses Python v3.8. 



The following table enlists the preinstalled software and tools in the Schematics worker images.



 Runtime-terraform-job image 



Schematics runtime terrafom job image

 Software Versions In agent Description 

 Terraform CLI 1.0.x, 1.1.x, <br>1.2.x, 1.3.x 1.3.x Terraform CLI 
 Ansible v2.9.27 v2.9.27 For use by the [ansible-provisioner](https://github.com/radekg/terraform-provisioner-ansible) for Terraform. <br>It is recommended to use the Schematics Actions to run your Ansible automation. 
 IBM Cloud CLI Latest Latest Latest version of the IBM Cloud CLI plug-ins are pre-installed. For your Terraform automation, it is recommended to use the Terraform provider plugi-ns for IBM Cloud. 
 JQ v1.6 Yes As the [JSON processor](https://cloud.ibm.com/docs/solution-tutorials?topic=solution-tutorials-tutorialsgetting-started-macos_jq) in your Terraform automation. 
 Kubectl client Yes For use in your Terraform automation. It is recommended to use the Terraform provider plug-ins for Kubernetes. 
 OpenShift client Yes Red Hat OpenShift CLI for your Terraform automation. It is recommended to use the Terraform provider plug-ins for IBM Cloud and Kubernetes. 
 Python v3.6 No For use in your Terraform automation. 
 Python libraries netaddr No Red Hat OpenShift CLI for your Terraform automation.
For more information about the GitHub Terraform provider, see the [GitHub Provider documentation](https://registry.terraform.io/providers/integrations/github/latest/docs). For more information about the GitLab Terraform provider, see the [GitLab Provider documentation](https://registry.terraform.io/providers/gitlabhq/gitlab/latest/docs).
* Can I manage GitHub, GitLab, and Git Repos and Issue Tracking by using an API?

You can use HTTP APIs or selected programming language SDKs to add GitHub, GitLab, and Git Repos and Issue Tracking tool integrations to a toolchain, to update those tool integrations, or to remove those tool integrations from a toolchain. For more information about working with the GitHub, GitLab, and Git Repos and Issue Tracking tool integrations, see [Working with tool integrations](https://cloud.ibm.com/docs/ContinuousDelivery?topic=ContinuousDelivery-integrations) and [Creating toolchains with Git](https://cloud.ibm.com/docs/ContinuousDelivery?topic=ContinuousDelivery-toolchains_git).

You might be able to use APIs to work directly with some repos. For more information about the GitHub API, see [REST API](https://docs.github.com/en/rest). For more information about the GitLab API, see [REST API](https://docs.gitlab.com/ee/api).
* What is the difference between the initialization block and the parameters block in Git tool integration Terraform resources?

In a Git tool integration Terraform resource, the initialization block consists of arguments that control how the tool integration prepares and binds itself to a specific target repo. If you change any of the arguments in the initialization block, Terraform deletes the tool integration from the toolchain and creates a replacement tool integration. All of the arguments in the initialization block are annotated with the Terraform behavior Forces new resource.
For more information, see the [data model for Foundbite](https://cloudant.com/blog/foundbites-data-model-relational-db-vs-nosql-on-cloudant/), or the [example from our friends at Twilio](https://www.twilio.com/blog/2013/01/building-a-real-time-sms-voting-app-part-3-scaling-node-js-and-couchdb.html).



* When must I make my documents immutable?

If you're changing the same piece of state at a rate of once per second or more, consider making your documents immutable. This practice significantly reduces the chance that you create conflicted documents.

Conversely, if you're updating a specific document less than once every 10 seconds, an update-in-place data model - that is, updating existing documents - simplifies your application code considerably.

Typically, data models based on immutable data require the use of views to summarize the documents that include the current state. As views are precomputed, this process most likely doesn't adversely affect application performance.
* Why does this help me consider immutable data?

Behind the https://$ACCOUNT.cloudant.com/ interface is a distributed database. Within the cluster, documents are bucketed into a number of shards that collectively form the database. These shards are then distributed across nodes in the cluster. This practice allows the support of databases many terabytes in size.

By default, the database is split into shards. Each shard has three copies, or shard replicas, which reside on a different node of the database cluster. Sharding allows the database to continue serving requests if a node fails, so saving a document involves writing to three nodes. If two updates are made concurrently to the same document, a subset of nodes might accept the first update, and another subset might accept the second update. When the cluster detects this discrepancy, it combines the documents in the same way as normal replication does for concurrent updates by creating a conflict.
* Why do I need to worry about conflicted documents?

Conflicted documents harm performance.
: This plan offers a new consumption model using Apache Spark whereby resources are allocated and consumed only when Spark workloads are running.

Capabilities available in the IBM Analytics Engine Standard serverless plan for Apache Spark include:



* Running Spark batch and streaming applications
* Creating and working with Jupyter kernels for interactive use cases
* Running Spark batch applications through an Apache Livy like interface
* Customizing instance with your own libraries
* Autoscaling Spark workloads
* Aggregating logs of your Spark workloads to the Log Analysis server



To get started using the serverless plan, see [Getting started using serverless IBM Analytics Engine instances](https://cloud.ibm.com/docs/AnalyticsEngine?topic=AnalyticsEngine-getting-started).
* [Control applications and jobs commands](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-cmdcontrol-commands)
* [Get information about apps commands](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-cmdget-info-commands)
* [Specifying a buildpack version](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-cmdspecify-buildpack)
* [Next steps](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-cmdmigrate-cf-ce-next-cmd)



[Migrating Cloud Foundry applications to Code Engine FAQ](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-faqmigrate-cf-ce-faq)



* [Can I use a custom URL with Code Engine?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-faqcustomurl)
* [My app contains a specific route, Can I use the same route?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-faqsameroute)
* [Can I stop my app?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-faqapp_stop)
* [Why do I have so many app instances?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-faqapp_more)
* [Why are my apps slow to respond?]
Sharding allows the database to continue serving requests if a node fails, so saving a document involves writing to three nodes. If two updates are made concurrently to the same document, a subset of nodes might accept the first update, and another subset might accept the second update. When the cluster detects this discrepancy, it combines the documents in the same way as normal replication does for concurrent updates by creating a conflict.





 Why do I need to worry about conflicted documents? 

Conflicted documents harm performance. A highly concurrent update-in-place pattern also increases the likelihood that writes get rejected. In that situation, the _rev parameter isn’t the expected one, which forces your application to retry and delay processing.

This conflicted-document scenario is significantly more likely to happen for updates that occur more often than once a second. Use immutable documents for updates that occur more than once every 10 seconds to be on the safe side.





 How can I use views to pre-calculate results rather than as search indexes? 

Rather than using views as search indexes, you can use the search get me all person documents and make the search extract the data for you. For example, you can retrieve all 10,000 person documents to calculate the combined hours worked. However, it's better to use a view with a composite key to pre-calculate the hours worked by year, month, day, half-day, and hour by using the _sum built-in reduce. You save work in your application and allow the database to concentrate on serving many small requests. This method is preferable to reading huge amounts of data from disk to service a single large request.





 Why this method helps me use views to pre-calculate results? 

It's straightforward. First, both maps and reduces are precomputed, so the result of a reduce function is a cheap operation. The operation cost is low even when compared to the significant amounts of IO required to stream hundreds or even thousands of documents from the on-disk storage.

At a deeper level, when a node receives a view request, it asks the nodes that hold the shard replicas of the view's database for the results of the view request from the documents in each shard.
"Person_name": "Robert De Niro",
"Movie_year": 1978,
},
)

findResult, _, err := service.PostFind(postFindOptions)
if err != nil {
panic(err)
}

b, _ := json.MarshalIndent(findResult, "", " ")
fmt.Println(string(b))

The previous Go example requires the following import block:

import (
"encoding/json"
"fmt"
"github.com/IBM/cloudant-go-sdk/cloudantv1"
)

See the following example result from the search:

{
"docs": [
{
"_id": "d9e6a7ae2363d6cfe81af75a392eb9f2",
"_rev": "1-9faa75d7ea524448b1456a6c69a4391a",
"Movie_runtime": 183,
"Movie_rating": "R",
"Person_name": "Robert De Niro",
"Movie_genre": "DW",
"Movie_name": "Deer Hunter, The",
"Person_pob": "New York, New York, USA",
"Movie_year": 1978,
"Person_dob": "1943-08-17"
}
],
"bookmark": "g2w ... c2o"
}
Show more

See the following example that uses HTTP to search within a range:

POST /my-movies/_find HTTP/1.1
Host: $SERVICE_URL
Content-Type: application/json
{
"selector": {
"Person_name":"Robert De Niro",
"Movie_year": {
"$in": [1974, 2009]
}
}
}
The following table lists and describes each of the variables that are used in the previous step.



Table 3. Variables for configuring the Delivery Pipeline with the API

 Variable Description 

 {region} The region in which the toolchain resides, for example, us-south. 
 {pipeline_id} The ID of the pipeline that is returned from the previous step where the pipeline tool integration was created. 
 {iam_token} A valid IAM bearer token. 





For more information about the Delivery Pipeline API, see the [API Docs](https://cloud.ibm.com/apidocs/tekton-pipeline).





 Creating a Delivery Pipeline for Tekton with Terraform 



1. To install the Terraform CLI and configure the IBM Cloud provider plug-in for Terraform, follow the tutorial for [Getting started with Terraform on IBM Cloud®](https://cloud.ibm.com/docs/ibm-cloud-provider-for-terraform?topic=ibm-cloud-provider-for-terraform-getting-started).
2. Create a Terraform configuration file that is named main.tf. In this file, add the configuration to create a pipeline by using the HashiCorp Configuration Language. For more information about using this configuration language, see the [Terraform documentation](https://www.terraform.io/docs/language/index.html).

A pipeline must belong to a toolchain. You can also create toolchains by [using Terraform](https://cloud.ibm.com/docs/ContinuousDelivery?topic=ContinuousDelivery-toolchains_getting_started&interface=terraform).

The following example creates a toolchain and a pipeline by using the specified Terraform resources.

data "ibm_resource_group" "group" {
name = "default"
}

resource "ibm_cd_toolchain" "my_toolchain" {
name = "terraform_toolchain"
resource_group_id = data.ibm_resource_group.group.id
}
Sharding allows the database to continue serving requests if a node fails, so saving a document involves writing to three nodes. If two updates are made concurrently to the same document, a subset of nodes might accept the first update, and another subset might accept the second update. When the cluster detects this discrepancy, it combines the documents in the same way as normal replication does for concurrent updates by creating a conflict.
* Why do I need to worry about conflicted documents?

Conflicted documents harm performance. A highly concurrent update-in-place pattern also increases the likelihood that writes get rejected. In that situation, the _rev parameter isn’t the expected one, which forces your application to retry and delay processing.

This conflicted-document scenario is significantly more likely to happen for updates that occur more often than once a second. Use immutable documents for updates that occur more than once every 10 seconds to be on the safe side.
* How can I use views to pre-calculate results rather than as search indexes?

Rather than using views as search indexes, you can use the search get me all person documents and make the search extract the data for you. For example, you can retrieve all 10,000 person documents to calculate the combined hours worked. However, it's better to use a view with a composite key to pre-calculate the hours worked by year, month, day, half-day, and hour by using the _sum built-in reduce. You save work in your application and allow the database to concentrate on serving many small requests. This method is preferable to reading huge amounts of data from disk to service a single large request.
* Why this method helps me use views to pre-calculate results?

It's straightforward. First, both maps and reduces are precomputed, so the result of a reduce function is a cheap operation. The operation cost is low even when compared to the significant amounts of IO required to stream hundreds or even thousands of documents from the on-disk storage.

At a deeper level, when a node receives a view request, it asks the nodes that hold the shard replicas of the view's database for the results of the view request from the documents in each shard.
[Create an app](https://cloud.ibm.com/docs/codeengine?topic=codeengine-application-workloads) and reference the undefined myliteralconfigmap3 configmap. For this example, create a Code Engine app that uses the icr.io/codeengine/hello image. When a request is sent to this sample app, the app reads the environment variable TARGET and prints Hello ${TARGET}. If this environment variable is empty, Hello World is returned. Reference the myliteralconfigmap3 configmap. For more information about the code that is used for this example, see [hello](https://github.com/IBM/CodeEngine/tree/main/hello).

By using the --no-wait option with the app create command, the app is created and does not wait for the app to be ready.

ibmcloud ce app create --name myapp --image icr.io/codeengine/hello --env-from-configmap myliteralconfigmap3 --force --no-wait
2. Use the app get command to display details of the job run, including the environment variable information. Notice that the app is created, but is not yet fully deployed.

ibmcloud ce app get --name myapp

Example output

Name: myapp
[...]
Status Summary: Application is deploying

Environment Variables:
Type Name Value
ConfigMap full reference myliteralconfigmap3
Image: icr.io/codeengine/hello
Resource Allocation:
CPU: 1
Ephemeral Storage: 400M
Memory: 4G

Runtime:
Concurrency: 100
Maximum Scale: 10
Minimum Scale: 0
Timeout: 300

Conditions:
Type OK Age Reason
ConfigurationsReady false 10s
Ready false 10s RevisionMissing : Configuration "myapp" is waiting for a Revision to become ready.
RoutesReady false 10s RevisionMissing : Configuration "myapp" is waiting for a Revision to become ready.

Events:
of the source code for this software, send an email to <agupta@ca.ibm.com>
identifying the IBM product and the GPL-licensed program for which you
are requesting the source code

GO-ETHEREUM [github.com/Zilliqa/gozilliqa-sdk],
GITHUB.COM/ZILLIQA/GOZILLIQA-SDK

END OF GNU GENERAL PUBLIC LICENSE, VERSION 3 NON-IBM-LICENSE INFORMATION
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

SIL OPEN FONT LICENSE 1.1

The Program includes some or all of the following works licensed under
the SIL OPEN FONT LICENSE 1.1

IBM PLEX TYPEFACE [carbon-components]

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL

-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
In addition, S3 compatibility means that the [AWS CLI](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-aws-cliaws-cli-configure-static-web) can also be used to define static website functionality from the command line. Also, creating and configuring a new hosted static website solution can be created using a GUI in the [Console](https://cloud.ibm.com/login) just by adding the option for Static Website when creating a bucket.





 Basic Configuration 

Hosting a static website on IBM Cloud® Object Storage starts with [creating a bucket](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-static-website-tutorialstatic-website-create-public-bucket) and configuring it for public access. Then, [upload](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-static-website-tutorialstatic-website-upload-content) your website content to your bucket. Finally, [configure the website](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-static-website-tutorialstatic-website-configure-options) to use your documents as an index for the site and to potentially display errors.

At minimum, your configuration should consist of a required index document for visitors to view by default, usually written in HTML and named index.html. An optional error document can help your visitors stay on track when they stray. Of course, you can always try for yourself using [this tutorial](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-static-website-tutorial).





 Advanced Configuration
Name: myliteralconfigmap2
[...]
Data:
---
TARGET: Happy day
7. Restart the application for the new data to take effect.

ibmcloud ce app update --name myhelloapp
8. Call the application again. This time, the app returns Hello Happy day, which is the value that is specified in the myliteralconfigmap2 configmap.

curl https://myhelloapp.d484a5d6-d10d.us-south.codeengine.appdomain.cloud

Example output

Hello Happy day







 Referencing configmaps that are not yet defined with the CLI 

If a configmap does not exist before it is referenced, an app does not deploy successfully and a job does not run successfully until the referenced configmap is created.

If you are working with an app or a job and the referenced configmap is not yet defined, you can use the --force option to avoid verification of the existence of the referenced configmap. The --force option can be used with the [app create](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-application-create), [app update](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-application-update), [job create](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-job-create), [job update](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-job-update), [jobrun submit](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-jobrun-submit), or [jobrun resubmit](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-jobrun-resubmit) commands.
* [Storing your Terraform templates](https://cloud.ibm.com/docs/schematics?topic=schematics-create-tf-configstore-template)



[Using environment variables with workspaces](https://cloud.ibm.com/docs/schematics?topic=schematics-set-parallelismset-parallelism)



* [Usage](https://cloud.ibm.com/docs/schematics?topic=schematics-set-parallelismenv-var-usage)



* [Passing TF_CLI_ARGS as env-vars](https://cloud.ibm.com/docs/schematics?topic=schematics-set-parallelismpassing-cli-args)
* [Example setting parallelism or TF_LOGS](https://cloud.ibm.com/docs/schematics?topic=schematics-set-parallelismparallelism-example)



* [List of Terraform environment variables](https://cloud.ibm.com/docs/schematics?topic=schematics-set-parallelismlist-special-env-vars)



[Running workspace plan](https://cloud.ibm.com/docs/schematics?topic=schematics-sch-plan-wkssch-plan-wks)



* [Before you begin](https://cloud.ibm.com/docs/schematics?topic=schematics-sch-plan-wksdisplay-prerequisites)
* [Generate a workspace plan using the UI](https://cloud.ibm.com/docs/schematics?topic=schematics-sch-plan-wksplan-wks-ui)



* [Verifying workspace plan](https://cloud.ibm.com/docs/schematics?topic=schematics-sch-plan-wksverify-wks-plan-ui)
You must be within the context of a [project](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-project) before you use configmap commands.

For more information about working with configmaps, see [Working with configmaps](https://cloud.ibm.com/docs/codeengine?topic=codeengine-configmap).

You can use either configmap or cm in your configmap commands. To see CLI help for the configmap commands, run ibmcloud ce configmap -h.



 ibmcloud ce configmap create 

Create a configmap.

ibmcloud ce configmap create --name CONFIGMAP_NAME (--from-env-file FILE | --from-file FILE | --from-file KEY=FILE | --from-literal KEY=VALUE) [--output OUTPUT] [--quiet]



 Command Options 

-n, --name
: The name of the configmap. Use a name that is unique within the project.



* The name must begin and end with a lowercase alphanumeric character.
* The name must be 253 characters or fewer and can contain lowercase letters, numbers, periods (.), and hyphens (-).



This value is required.

--from-env-file, -e
: Create a configmap from a file which contains one or more lines that match the format KEY=VALUE. You must provide the path to the file as a value. Each line from the specified file is added as a key-value pair. Any lines in the specified file that are empty or begin with are ignored. This value is required if --from-literal or --from-file is not specified.

--from-file, -f
: Create a configmap from a file. You must provide the path to the file as a value. This value is required if --from-literal or --from-env-file is not specified.