triangle-utils 1.4.103 → 1.4.105

package/dist/src/UtilsDynamoDB.d.ts

@@ -14,9 +14,10 @@ export declare class UtilsDynamoDB {
         last_key?: Record<string, any>;
         print?: boolean;
     }): Promise<Record<string, any>[]>;
-    get(table: string, key: Record<string, any>, options?: {
+    get(table_name: string, key: Record<string, any>, options?: {
         consistent?: boolean;
     }): Promise<Record<string, any> | undefined>;
+    batch_get(table_name: string, keys: Record<string, any>[]): Promise<Record<string, any>[]>;
     get_max(table_index_name: string, primary_key: Record<string, string | number>): Promise<Record<string, any> | undefined>;
     query(table_index_name: string, primary_key: Record<string, any>, options?: {
         reverse?: boolean;
@@ -57,6 +58,8 @@ export declare class UtilsDynamoDB {
     remove(table_name: string, key: Record<string, any>, attributes: string[]): Promise<void>;
     create(table_name: string, key: Record<string, any>, attributes?: Record<string, any>): Promise<void>;
     delete(table_name: string, key: Record<string, any>): Promise<void>;
+    batch_put(table_name: string, items: Record<string, any>[]): Promise<void>;
+    batch_delete(table_name: string, keys: Record<string, any>[]): Promise<void>;
     duplicate_attribute(table_name: string, attribute_name: string, new_attribute_name: string): Promise<void>;
     remove_attribute(table_name: string, attribute_name: string): Promise<undefined>;
 }

package/dist/src/UtilsDynamoDB.js

@@ -147,7 +147,7 @@ export class UtilsDynamoDB {
         const items = segments.flat().filter(is_item);
         return items;
     }
-    async get(table, key, options = {}) {
+    async get(table_name, key, options = {}) {
         const consistent = options.consistent !== undefined ? options.consistent : false;
         const converted_key = convert_input(key)?.M;
         if (converted_key === undefined) {
@@ -155,7 +155,7 @@ export class UtilsDynamoDB {
         }
         const item = await this.dynamodb.getItem({
             ConsistentRead: consistent,
-            TableName: table,
+            TableName: table_name,
             Key: converted_key
         })
             .then(response => response.Item);
@@ -168,6 +168,27 @@ export class UtilsDynamoDB {
         }
         return converted_output;
     }
+    async batch_get(table_name, keys) {
+        const dynamodb_keys = keys.map(key => convert_input(key)?.M)
+            .filter(dynamodb_key => dynamodb_key !== undefined);
+        const items = [];
+        for (let i = 0; i < dynamodb_keys.length; i += 100) {
+            let next_dynamodb_keys = dynamodb_keys.slice(i, i + 100);
+            while (next_dynamodb_keys.length > 0) {
+                const response = await this.dynamodb.batchGetItem({
+                    RequestItems: {
+                        [table_name]: {
+                            Keys: next_dynamodb_keys
+                        }
+                    }
+                });
+                const new_items = response.Responses?.[table_name]?.map(item => convert_output({ M: item })) || [];
+                items.push(...new_items);
+                next_dynamodb_keys = response.UnprocessedKeys?.[table_name]?.Keys || [];
+            }
+        }
+        return items;
+    }
     async get_max(table_index_name, primary_key) {
         const table_name = table_index_name.split(":")[0];
         const index_name = table_index_name.split(":")[1];
@@ -477,6 +498,44 @@ export class UtilsDynamoDB {
             Key: converted_key
         });
     }
+    async batch_put(table_name, items) {
+        const dynamodb_items = items.map(item => convert_input(item)?.M)
+            .filter(dynamodb_item => dynamodb_item !== undefined);
+        for (let i = 0; i < dynamodb_items.length; i += 100) {
+            let next_dynamodb_requests = dynamodb_items.slice(i, i + 100).map(next_dynamodb_item => ({
+                PutRequest: {
+                    Item: next_dynamodb_item
+                }
+            }));
+            while (next_dynamodb_requests.length > 0) {
+                const response = await this.dynamodb.batchWriteItem({
+                    RequestItems: {
+                        [table_name]: next_dynamodb_requests
+                    }
+                });
+                next_dynamodb_requests = response.UnprocessedItems?.[table_name] || [];
+            }
+        }
+    }
+    async batch_delete(table_name, keys) {
+        const dynamodb_keys = keys.map(key => convert_input(key)?.M)
+            .filter(dynamodb_key => dynamodb_key !== undefined);
+        for (let i = 0; i < dynamodb_keys.length; i += 100) {
+            let next_dynamodb_requests = dynamodb_keys.slice(i, i + 100).map(next_dynamodb_key => ({
+                DeleteRequest: {
+                    Key: next_dynamodb_key
+                }
+            }));
+            while (next_dynamodb_requests.length > 0) {
+                const response = await this.dynamodb.batchWriteItem({
+                    RequestItems: {
+                        [table_name]: next_dynamodb_requests
+                    }
+                });
+                next_dynamodb_requests = response.UnprocessedItems?.[table_name] || [];
+            }
+        }
+    }
     async duplicate_attribute(table_name, attribute_name, new_attribute_name) {
         const table_metadata = await this.dynamodb.describeTable({
             TableName: table_name

package/dist/src/f.js

@@ -232,5 +232,9 @@ const utils = new TriangleUtils(config);
 //     }
 // )
 // console.log(response)
-const coordinates = await utils.bedrock.cohere_invoke("global.cohere.embed-v4:0", "yerrp");
-console.log(coordinates);
+// const coordinates = await utils.bedrock.cohere_invoke("global.cohere.embed-v4:0", "yerrp")
+// console.log(coordinates)
+const scout_ids = await utils.dynamodb.scan("scouts")
+    .then(scouts => scouts.map(scout => scout.scout_id));
+const scouts = await utils.dynamodb.batch_get("scouts", scout_ids.slice(0, 150).map(scout_id => ({ scout_id: scout_id })));
+console.log(scouts.length);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "triangle-utils",
-    "version": "1.4.103",
+    "version": "1.4.105",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",
     "directories": {

package/src/UtilsBee.ts

@@ -131,7 +131,7 @@ export class UtilsBee {
                     console.log("Failed to get YouTube Subtitles:", response.status)
                     continue
                 }
-                const data : Record<string, any> = await response.json()
+                const data : any = await response.json()
                 const subtitles = data.subtitles
 
                 if (subtitles === undefined) {

package/src/UtilsDynamoDB.ts

@@ -1,4 +1,4 @@
-import { AttributeValue, DynamoDB, QueryCommandInput, QueryCommandOutput, ScanCommandInput, ScanCommandOutput, UpdateItemCommandInput } from "@aws-sdk/client-dynamodb"
+import { AttributeValue, DynamoDB, QueryCommandInput, QueryCommandOutput, ScanCommandInput, ScanCommandOutput, UpdateItemCommandInput, WriteRequest } from "@aws-sdk/client-dynamodb"
 
 function convert_output(dynamodb_output : AttributeValue) : string | boolean | number | any[] | Set<any> | Record<string, any> | undefined {
     if (dynamodb_output.S !== undefined) {
@@ -173,7 +173,7 @@ export class UtilsDynamoDB {
     }
 
     async get(
-        table : string,
+        table_name : string,
         key : Record<string, any>,
         options : {
             consistent? : boolean
@@ -186,7 +186,7 @@ export class UtilsDynamoDB {
         }
         const item = await this.dynamodb.getItem({
             ConsistentRead : consistent,
-            TableName : table,
+            TableName : table_name,
             Key : converted_key
         })
             .then(response => response.Item)
@@ -200,6 +200,32 @@ export class UtilsDynamoDB {
         return converted_output
     }
 
+    async batch_get(
+        table_name : string,
+        keys : Record<string, any>[]
+    ) : Promise<Record<string, any>[]> {
+        const dynamodb_keys = keys.map(key => convert_input(key)?.M)
+            .filter(dynamodb_key => dynamodb_key !== undefined)
+            
+        const items = []
+        for (let i = 0; i < dynamodb_keys.length; i += 100) {
+            let next_dynamodb_keys = dynamodb_keys.slice(i, i + 100)
+            while (next_dynamodb_keys.length > 0) {
+                const response = await this.dynamodb.batchGetItem({
+                    RequestItems : {
+                        [table_name] : {
+                            Keys : next_dynamodb_keys
+                        }
+                    }
+                })
+                const new_items : any[] = response.Responses?.[table_name]?.map(item => convert_output({ M : item })) || []
+                items.push(...new_items)
+                next_dynamodb_keys = response.UnprocessedKeys?.[table_name]?.Keys || []
+            }
+        }
+        return items
+    }
+
     async get_max(
         table_index_name : string,
         primary_key : Record<string, string | number>
@@ -587,6 +613,54 @@ export class UtilsDynamoDB {
         })
     }
 
+    async batch_put(
+        table_name : string,
+        items : Record<string, any>[]
+    ) : Promise<void> {
+        const dynamodb_items = items.map(item => convert_input(item)?.M)
+            .filter(dynamodb_item => dynamodb_item !== undefined)
+            
+        for (let i = 0; i < dynamodb_items.length; i += 100) {
+            let next_dynamodb_requests : WriteRequest[] = dynamodb_items.slice(i, i + 100).map(next_dynamodb_item => ({
+                PutRequest : {
+                    Item : next_dynamodb_item
+                }
+            }))
+            while (next_dynamodb_requests.length > 0) {
+                const response = await this.dynamodb.batchWriteItem({
+                    RequestItems : {
+                        [table_name] : next_dynamodb_requests
+                    }
+                })
+                next_dynamodb_requests = response.UnprocessedItems?.[table_name] || []
+            }
+        }
+    }
+
+    async batch_delete(
+        table_name : string,
+        keys : Record<string, any>[]
+    ) : Promise<void> {
+        const dynamodb_keys = keys.map(key => convert_input(key)?.M)
+            .filter(dynamodb_key => dynamodb_key !== undefined)
+            
+        for (let i = 0; i < dynamodb_keys.length; i += 100) {
+            let next_dynamodb_requests : WriteRequest[] = dynamodb_keys.slice(i, i + 100).map(next_dynamodb_key => ({
+                DeleteRequest : {
+                    Key : next_dynamodb_key
+                }
+            }))
+            while (next_dynamodb_requests.length > 0) {
+                const response = await this.dynamodb.batchWriteItem({
+                    RequestItems : {
+                        [table_name] : next_dynamodb_requests
+                    }
+                })
+                next_dynamodb_requests = response.UnprocessedItems?.[table_name] || []
+            }
+        }
+    }
+
     async duplicate_attribute(table_name : string, attribute_name : string, new_attribute_name : string) : Promise<void>{
         const table_metadata = await this.dynamodb.describeTable({
             TableName : table_name

package/src/f.ts

@@ -270,6 +270,12 @@ const utils = new TriangleUtils(config)
 // )
 // console.log(response)
 
-const coordinates = await utils.bedrock.cohere_invoke("global.cohere.embed-v4:0", "yerrp")
+// const coordinates = await utils.bedrock.cohere_invoke("global.cohere.embed-v4:0", "yerrp")
 
-console.log(coordinates)
+// console.log(coordinates)
+
+const scout_ids = await utils.dynamodb.scan("scouts")
+    .then(scouts => scouts.map(scout => scout.scout_id))
+
+const scouts = await utils.dynamodb.batch_get("scouts", scout_ids.slice(0, 150).map(scout_id => ({ scout_id : scout_id })))
+console.log(scouts.length)