vania-janet/multiturn-rag-retrieval-data huggingface dataset:
The maximum length is 255 characters. The minimum length is 1 character. The value must match regular expression /[!a-zA-Z 0-9-_/.?:'";,+=@$%^&() ]/.

[--destination-id DESTINATION-ID] (string)
: The destination ID to be set for subscription.

The maximum length is 150 characters. The minimum length is 36 characters. The value must match regular expression /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/.

[--topic-id TOPIC-ID] (string)
: The topic ID to be set for subscription.

The maximum length is 150 characters. The minimum length is 36 characters. The value must match regular expression /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/.

[-attributes ATTRIBUTES] ([SubscriptionCreateAttributes](https://cloud.ibm.com/docs/cli?topic=cli-event-notifications-clien-cli-subscription-example-schema))
: The attributes to be set for subscription.
* Examples:



* The following example shows the format of the SubscriptionCreateAttributes object.

{
"add_notification_payload" : true,
"signing_enabled" : true
}
* Attributes flag syntax in case of SMS subscription to be created.

{
"to" :["+19667895490", "+19845678321"]
}
* Attributes flag syntax in case of email subscription to be created.

{
The maximum length is 36 characters. The minimum length is 36 characters. The value must match regular expression /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/.

--secret-group-patch (generic map)
: The request body to update a secret group.

Provide a JSON string option or specify a JSON file to read from by providing a filepath option that begins with a @, e.g. --secret-group-patch=@path/to/file.json.

--name (string)
: The name of your secret group.

The maximum length is 64 characters. The minimum length is 2 characters. The value must match regular expression /^[A-Za-z0-9](?:_-\.[A-Za-z0-9]+)$/.

--description (string)
: An extended description of your secret group.

To protect your privacy, do not use personal data, such as your name or location, as a description for your secret group.

The maximum length is 1024 characters. The minimum length is 0 characters. The value must match regular expression /(.?)/.





 Example 

ibmcloud secrets-manager secret-group-update --id=d898bb90-82f6-4d61-b5cc-b079b66cfa76 --name=my-secret-group --description='Extended description for this group.'





 Example output 

Example of SecretGroup response

{
"created_at" : "2020-10-05T21:33:11Z",
"description" : "Extended description for this group.",
"id" : "d898bb90-82f6-4d61-b5cc-b079b66cfa76",
"name" : "my-secret-group",
If the Periodic timer (cron) event data exceeds the limit, a size limit exceeded error is given. If you receive this error, try reducing the cron event data size to less than 4096 bytes.

For more information about troubleshooting subscriptions, see [Debugging subscriptions](https://cloud.ibm.com/docs/codeengine?topic=codeengine-troubleshoot-subscriptions).





 Increasing limits 

Limit values are fixed, but can be increased by [contacting IBM support and creating a support case](https://cloud.ibm.com/docs/codeengine?topic=codeengine-get-support).
The maximum length is 50 characters. The minimum length is 1 character. The value must match regular expression /[!a-zA-Z 0-9-_/.?:'";,+=@$%^&() ]/.

[--instance-id INSTANCE-ID] (string)
: The unique identifier for IBM Cloud Event Notifications instance.

The maximum length is 36 characters. The minimum length is 36 characters. The value must match regular expression /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]/.

[--description DESCRIPTION] (string)
: The description to be set for subscription.

The default value is ``. The maximum length is 255 characters. The minimum length is 1 character. The value must match regular expression /[!a-zA-Z 0-9-_/.?:'";,+=@$%^&() ]/.

[--destination-id DESTINATION-ID] (string)
: The destination ID to be set for subscription.

The maximum length is 150 characters. The minimum length is 36 characters. The value must match regular expression /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/.

[--topic-id TOPIC-ID] (string)
: The topic ID to be set for subscription.

The maximum length is 150 characters. The minimum length is 36 characters.
def multi_part_upload(bucket_name, item_name, file_path):
try:
print("Starting file transfer for {0} to bucket: {1}n".format(item_name, bucket_name))
 set 5 MB chunks
part_size = 1024 * 1024 * 5

 set threadhold to 15 MB
file_threshold = 1024 * 1024 * 15

 set the transfer threshold and chunk size
transfer_config = ibm_boto3.s3.transfer.TransferConfig(
multipart_threshold=file_threshold,
multipart_chunksize=part_size
)

 the upload_fileobj method will automatically execute a multi-part upload
 in 5 MB chunks for all files over 15 MB
with open(file_path, "rb") as file_data:
cos.Object(bucket_name, item_name).upload_fileobj(
Fileobj=file_data,
Config=transfer_config
)

print("Transfer for {0} Complete!n".format(item_name))
except ClientError as be:
print("CLIENT ERROR: {0}n".format(be))
except Exception as e:
print("Unable to complete multi-part upload: {0}".format(e))
Show more

SDK References



* Classes



* [Object](https://ibm.github.io/ibm-cos-sdk-python/reference/services/s3.htmlobject)
* [TransferConfig](https://ibm.github.io/ibm-cos-sdk-python/reference/customizations/s3.htmls3-transfers)



* Methods



* [upload_fileobj](https://ibm.github.io/ibm-cos-sdk-python/reference/services/s3.htmlS3.Object.upload_fileobj)









 Manually run a multi-part upload
x-amz-request-id: 9a2ae3e1-76dd-4eec-a8f2-1a7f60f63483
Access-Control-Allow-Origin: 
Access-Control-Allow-Methods: PUT
Access-Control-Allow-Credentials: true
Vary: Origin, Access-Control-Request-Headers, Access-Control-Allow-Methods
Content-Length: 0

--------------------





 Uploading objects in multiple parts 

When working with larger objects, multipart upload operations are recommended to write objects into IBM Cloud® Object Storage. An upload of a single object can be performed as a set of parts and these parts can be uploaded independently in any order and in parallel. Upon upload completion, Object Storage then presents all parts as a single object. This provides many benefits: network interruptions do not cause large uploads to fail, uploads can be paused and restarted over time, and objects can be uploaded as they are being created.

Multipart uploads are only available for objects larger than 5 MB. For objects smaller than 50 GB, a part size of 20 MB to 100 MB is recommended for optimum performance. For larger objects, part size can be increased without significant performance impact.

Due to the additional complexity involved, it is recommended that developers make use of a library that provides multipart upload support.

Incomplete multipart uploads do persist until the object is deleted or the multipart upload is aborted with AbortIncompleteMultipartUpload. If an incomplete multipart upload is not aborted, the partial upload continues to use resources. Interfaces should be designed with this point in mind, and clean up incomplete multipart uploads.

There are three phases to uploading an object in multiple parts:



1. The upload is initiated and an UploadId is created.
2. Individual parts are uploaded specifying their sequential part numbers and the UploadId for the object.
3.
* Optional: Max number of PARTS which will be uploaded to S3 that calculates the part size of the object to be uploaded. Limit is 10,000 parts.



* Flag: --max-upload-parts PARTS



* Optional: The buffer SIZE (in bytes) to use when buffering data into chunks and ending them as parts to S3. The minimum allowed part size is 5MB.



* Flag: --part-size SIZE



* Optional: Setting this value to true will cause the SDK to avoid calling AbortMultipartUpload on a failure, leaving all successfully uploaded parts on S3 for manual recovery.



* Flag: --leave-parts-on-errors



* Optional: Specifies CACHING_DIRECTIVES for the request/reply chain.



* Flag: --cache-control CACHING_DIRECTIVES



* Optional: Specifies presentational information (DIRECTIVES).



* Flag: --content-disposition DIRECTIVES



* Optional: Specifies what content encodings (CONTENT_ENCODING) have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field.



* Flag: --content-encoding CONTENT_ENCODING



* Optional: The LANGUAGE the content is in.



* Flag: --content-language LANGUAGE



* Optional: SIZE of the body in bytes. This parameter is useful when the size of the body cannot be determined automatically.



* Flag: --content-length SIZE



* Optional: The base64-encoded 128-bit MD5 digest of the data.



* Flag: --content-md5 MD5



* Optional: A standard MIME type describing the format of the object data.



* Flag: --content-type MIME



* Optional: A MAP of metadata to store.



* Flag: --metadata MAP JSON Syntax: The --metadata flag takes the file:// prefix that is used to load the JSON structure from the specified file.





{
"file_name": "file_20xxxxxxxxxxxx45.zip",
"label": "texas",
"state": "Texas",
parameters The maximum size of the parameters that can be attached in MB. The size limit for the total parameters on creating or updating of an action, package, or trigger is 5 MB. An entity with too large parameters is rejected on trying to create or update it. This limit is fixed and cannot be changed. 5 0 5 
 proculimit The maximum number of processes available to the action container is 1024. This limit is fixed and cannot be changed. When an action is invoked, the docker run command uses the argument --pids-limit 1024 to set the proculimit value. For more information, see the [docker run](https://docs.docker.com/engine/reference/commandline/run/) command-line reference documentation. 1024 0 1024 
 result The maximum output size of an action invocation result in MB. This limit is fixed and cannot be changed. 5 0 5 
 sequenceMaxActions The maximum number of actions that comprise a sequence. This limit is fixed and cannot be changed. 50 0 50 
 timeout The timeout limit N is in the range 100 ms to 600000 ms, and is set per action in milliseconds. You can change the timeout limit when an action is created. A container that runs longer than N milliseconds is terminated. 60000 100 60000 







 Web action limits 



Table 2. Web action limits

 Parameter Limit 

 Request headers 8 KB cumulative 
 Response headers 4 KB cumulative 







 Sequence limits 

A sequence does not have limits that are separate from those limits of each action that is contained within the sequence. Because a sequence is a pipeline of actions, a failure in one action breaks the pipeline. For example, if one action times out, the entire sequence is exited with that failure.





 Trigger rate limits 

Triggers are subject to a firing rate per minute as documented in the following table.



Table 3. Default limits for triggers

 Limit Description Default Min Max 

 minuteRate The rate limit N is set to 5000 and limits the number of triggers that a user can fire in 1-minute windows. You cannot change the trigger limit when a trigger is created.
: The maximum log size in MB for the action. The default value is 10 MB.

--main ENTRY_METHOD_NAME
: If the action's entry method is not main, specify the custom name. This flag is required when the entry method is not main. For some runtimes, such as Java, the name must be the fully qualified method.

--memory MEMORY_LIMIT
: The maximum memory limit in MB for your action. The default is 256 MB.

--native
: You can use the --native argument as shorthand for --docker openwhisk/dockerskeleton. By using this argument, you can create and deploy an executable that runs inside the standard Docker action SDK. \n - When you create a Docker image, an executable is created inside the container at /action/exec. Copy the /action/exec file to your local file system and compress it into exec.zip. \n - Create a Docker action that receives the executable as initialization data. The --native argument replaces the --docker openwhisk/dockerskeleton argument.

--paramKEYVALUE, -pKEYVALUE
: Parameter VALUES in the KEYVALUE format. This flag is optional.

--param-fileFILE, -PFILE
: A JSON file that contains parameters KEYS and VALUES. This flag is optional.

--sequenceACTION_NAME, ACTION_NAME
: Create an action sequence by specifying the name of related actions.

--timeoutLIMIT, -tLIMIT
: The timeout limit in milliseconds. The default value is 60000 milliseconds. When the timeout is reached, the action is terminated.

--web yes|true|raw|no|false
: Treat the action as a web action, a raw HTTP web action, or as a standard action. Specify yes or true for a web action, raw for a raw HTTP web action, or no or false for a standard action. To secure your web action, also include the --web-secure option.
For example, for a file share that's 25 GB, you can increase IOPS anywhere in the range 100-1,000 IOPS with a custom profile. If you later [increase the size of a file share](https://cloud.ibm.com/docs/vpc?topic=vpc-file-storage-expand-capacity) to the next highest band, you can increase the IOPS again.
* Adjust IOPS from an IOPS tier profile to a custom or dp2 profile. In this case, the file share size restricts the custom or dp2 band that you select. For example, if you're adjusting IOPS for file share with a 3 IOPS/GB profile and it's 12,000 GB, you can adjust the IOPS by using a custom or dp2 profile. It's possible because both support a share size of 12,000 GB. If the file share size was greater than 16,000 GB, the custom profile would not support adjusting IOPS, but the dp2 profile would because it supports share sizes to 32,000 GB. The IOPS tier maximum sizes are 32,000 GB for 3 IOPS/GB, 9,600 GB for 5 IOPS/GB, and 4,800 GB for 10 IOPS/GB. When you move from a tiered profile to a custom or dp2 profile, billing is update based on the specified IOPS.
* Adjust IOPS from a custom or dp2 profile to an IOPS tier profile. Again, you're restricted to which IOPS tier profile you can select by the file share size. When you move from a custom or dp2 profile to any tiered profile, billing is updated, and the IOPS is adjusted according to the profile.



To adjust a file share's IOPS, the file share must be in a stable state. Your user authorization is verified before IOPS is adjusted.
The uploaded JSON file must use UTF-8 encoding, without byte order mark (BOM) encoding. The JSON cannot contain tabs, newlines, or carriage returns.

The maximum size for a skill JSON file is 10 MB. If you need to upload a larger skill, consider using the REST API. For more information, see the [API Reference](https://cloud.ibm.com/apidocs/assistant/assistant-v1?curl=createworkspace).

Click Upload.

If you have trouble uploading a skill, see [Troubleshooting skill upload issues](https://cloud.ibm.com/docs/assistant?topic=assistant-skill-dialog-addskill-dialog-add-import-errors).
* If you have created a dialog skill already, the Add existing skill tab is displayed, and you can click to add an existing skill.



3. Specify the details for the skill:



* Name: A name no more than 64 characters in length. A name is required.
* Description: An optional description no more than 128 characters in length.
* Language: The language of the user input the skill will be trained to understand. The default value is English.



4. For Skill type, choose Dialog.
5. Click Create skill.



After you create the dialog skill, it appears as a tile on the Skills page. Now, you can start identifying the user goals that you want the dialog skill to address.



* To add prebuilt intents to your skill, see [Using content catalogs](https://cloud.ibm.com/docs/assistant?topic=assistant-catalog).
* To define your own intents, see [Defining intents](https://cloud.ibm.com/docs/assistant?topic=assistant-intents).



The dialog skill cannot interact with customers until it is added to an assistant and the assistant is deployed. See [Creating an assistant](https://cloud.ibm.com/docs/assistant?topic=assistant-assistant-add).



 Troubleshooting skill upload issues
The maximum length is 128 characters. The value must match regular expression /^\.\-0-9a-zA-Z] +$/.
--name (string): The name of the configuration. Required.
The maximum length is 64 characters. The minimum length is 1 character. The value must match regular expression /^a-zA-Z0-9]a-zA-Z0-9-_ ] !!$/.
--locator-id (string): A dotted value of catalogID.versionID. Required.
The maximum length is 512 characters. The minimum length is 1 character. The value must match regular expression /^(?\s)(?.\s$)\.0-9a-z-A-Z_-] ] +$/.
--labels ([string): A collection of configuration labels.
The default value is ]. The list items must match regular expression /^_\-a-z0-9:/=] ! +$/. The maximum length is 10000 items. The minimum length is 0 items.
--description (string): The description of the project configuration.
The default value is ``. The maximum length is 1024 characters. The minimum length is 0 characters. The value must match regular expression /^$|^(?\s).\S$/.
--authorizations (ProjectConfigAuth]ProjectConfigAuth] ): The authorization for a configuration. You can authorize by using a trusted profile or an API key in Secrets Manager.
Provide a JSON string option or specify a JSON file to read from by providing a filepath option that begins with a @, e.g. --authorizations=@path/to/file.json.
--compliance-profile (ProjectConfigComplianceProfile]ProjectConfigComplianceProfile] ): The profile required for compliance.
print("Bucket: {0} deleted!".format(bucket_name))
log_done()
except ClientError as be:
log_client_error(be)
except Exception as e:
log_error("Unable to delete bucket: {0}".format(e))

def upload_large_file(bucket_name, item_name, file_path):
print("Starting large file upload for {0} to bucket: {1}".format(item_name, bucket_name))

 set the chunk size to 5 MB
part_size = 1024 * 1024 * 5

 set threadhold to 5 MB
file_threshold = 1024 * 1024 * 5

 set the transfer threshold and chunk size in config settings
transfer_config = ibm_boto3.s3.transfer.TransferConfig(
multipart_threshold=file_threshold,
multipart_chunksize=part_size
)

 create transfer manager
transfer_mgr = ibm_boto3.s3.transfer.TransferManager(cos_cli, config=transfer_config)

try:
 initiate file upload
future = transfer_mgr.upload(file_path, bucket_name, item_name)

 wait for upload to complete
future.result()

print ("Large file upload complete!")
except Exception as e:
print("Unable to complete large file upload: {0}".format(e))
finally:
transfer_mgr.shutdown()

 Constants for IBM COS values
COS_ENDPOINT = "<endpoint>" example: https://s3.us-south.cloud-object-storage.appdomain.cloud
COS_API_KEY_ID = "<api-key>" example: xxxd12V2QHXbjaM99G9tWyYDgF_0gYdlQ8aWALIQxXx4
If the expected size is greater than 1KB, the [max_length inputs meta-data](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-template-schema-yamlbp-inputs-max-len) can be defined to set the length that Blueprints should accept.

A value larger than 1KB or the specified length will result in the error Length for variable <variable name> greater than the given length
* Why do blueprint operations require a blueprint ID?

In Schematics Blueprints, the displayed name is not a unique identifier. Only the blueprint ID that is generated at create time is unique. This unique blueprint ID is needed by the command line to identify the specific environment to be worked on. Blueprint IDs are unique globally and generated from the user supplied name at create time.
* What URL format is used for referencing blueprint templates and input files?

In the Blueprints UI, the URL specification for the template and input files uses the Git object path syntax as used by the GitHub API and UI to access and retrieve files. This specifies both the repository URL and file name as a single string.

All information to reference the file in the Git repo, its branch and sub-folder must be specified as part of the URL string. This includes the template or input file name. For example, https://github.com/Cloud-Schematics/blueprint-basic-example/blob/main/basic-blueprint.yaml.

The link can point to the template file in the main branch, any other branch, or a subdirectory. The URL must include the template file name and must use the blob/branch/ pattern for the full path.



* Example for main blueprint.yaml - https://github.com/myorg/myrepo/blob/main/blueprint.yaml
* Example for blueprint.yaml in branches - https://github.com/myorg/myrepo/blob/mybranch/blueprint.yaml
Attribute Limit 

 Name 2 - 256 characters<br><br>The name of the secret can contain only alphanumeric characters, dashes, and dots. It must start and end with an alphanumeric character. 
 Description 2 - 1024 characters 
 Secret value / payload 512 KB 
 Labels 2 - 30 characters<br><br>30 labels per secret 
 Locks 1000 
 Custom metadata 10 KB 
 Version custom metadata 10 KB 







 Limits for SSL/TLS certificates 

The following limits apply to imported, private, or public certificates.



Table 8. TLS certificate limits

 Attribute Limit 

 Name 2 - 256 characters<br><br>The name of the secret can contain only alphanumeric characters, dashes, and dots. It must start and end with an alphanumeric character. 
 Description 2 - 1024 characters 
 Certificate 100 KB<br><br>Supported file type is .pem. The certificate must be a valid, X.509-based certificate. 
 Private key 100 KB<br><br>Private key file is limited to PEM-formatted content. If provided, the private key must match the certificate that you are importing. Only unencrypted private keys are supported. 
 Intermediate certificate 100 KB<br><br>Supported file type is .pem. If provided, the intermediate certificate must be a valid, X.509-based certificate. 
 Labels 2 - 30 characters<br><br>30 labels per secret 
 Versions 2 versions per certificate (current and previous)<br><br>For auditing purposes, the service retains the metadata of up to 50 versions for each secret, which you can review as part of a secret's [version history](https://cloud.ibm.com/docs/secrets-manager?topic=secrets-manager-version-history). 
 Locks 1000 
 Custom metadata 10 KB 
 Version custom metadata 10 KB 







 Limits for user credentials 

The following limits apply to user credentials.



Table 9. User credential limits

 Attribute Limit 

 Name 2 - 256 characters<br><br>The name of the secret can contain only alphanumeric characters, dashes, and dots.
upload_id = mp["UploadId"]

 min 20MB part size
part_size = 1024 * 1024 * 20
file_size = os.stat(file_path).st_size
part_count = int(math.ceil(file_size / float(part_size)))
data_packs = []
position = 0
part_num = 0

 begin uploading the parts
with open(file_path, "rb") as file:
for i in range(part_count):
part_num = i + 1
part_size = min(part_size, (file_size - position))

print("Uploading to {0} (part {1} of {2})".format(item_name, part_num, part_count))

file_data = file.read(part_size)

mp_part = cos_cli.upload_part(
Bucket=bucket_name,
Key=item_name,
PartNumber=part_num,
Body=file_data,
ContentLength=part_size,
UploadId=upload_id
)

data_packs.append({
"ETag":mp_part["ETag"],
"PartNumber":part_num
})

position += part_size

 complete upload
cos_cli.complete_multipart_upload(
Bucket=bucket_name,
Key=item_name,
UploadId=upload_id,
MultipartUpload={
"Parts": data_packs
}
)
print("Upload for {0} Complete!n".format(item_name))
except ClientError as be:
 abort the upload
cos_cli.abort_multipart_upload(
Bucket=bucket_name,
Key=item_name,
UploadId=upload_id
)