CINXE.COM

<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta name="generator" content="pdoc 14.5.1"/> <title>pinecone.control.pinecone_asyncio API documentation</title> <link rel="icon" href="./favicon-32x32.png"/> <style>/*! * Bootstrap Reboot v5.0.0 (https://getbootstrap.com/) * Copyright 2011-2021 The Bootstrap Authors * Copyright 2011-2021 Twitter, Inc. * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md) */*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans","Liberation Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";font-size:1rem;font-weight:400;line-height:1.5;color:#212529;background-color:#fff;-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}hr{margin:1rem 0;color:inherit;background-color:currentColor;border:0;opacity:.25}hr:not([size]){height:1px}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2}h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){h1{font-size:2.5rem}}h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){h2{font-size:2rem}}h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){h3{font-size:1.75rem}}h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){h4{font-size:1.5rem}}h5{font-size:1.25rem}h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[data-bs-original-title],abbr[title]{-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-left:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:.875em}mark{padding:.2em;background-color:#fcf8e3}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;text-decoration:underline}a:hover{color:#0a58ca}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;font-size:1em;direction:ltr;unicode-bidi:bidi-override}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:#d63384;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:.875em;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:1em;font-weight:700}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:#6c757d;text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]::-webkit-calendar-picker-indicator{display:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:left;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::file-selector-button{font:inherit}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}</style> <style>/*! syntax-highlighting.css */pre{line-height:125%;}span.linenos{color:inherit; background-color:transparent; padding-left:5px; padding-right:20px;}.pdoc-code .hll{background-color:#ffffcc}.pdoc-code{background:#f8f8f8;}.pdoc-code .c{color:#3D7B7B; font-style:italic}.pdoc-code .err{border:1px solid #FF0000}.pdoc-code .k{color:#008000; font-weight:bold}.pdoc-code .o{color:#666666}.pdoc-code .ch{color:#3D7B7B; font-style:italic}.pdoc-code .cm{color:#3D7B7B; font-style:italic}.pdoc-code .cp{color:#9C6500}.pdoc-code .cpf{color:#3D7B7B; font-style:italic}.pdoc-code .c1{color:#3D7B7B; font-style:italic}.pdoc-code .cs{color:#3D7B7B; font-style:italic}.pdoc-code .gd{color:#A00000}.pdoc-code .ge{font-style:italic}.pdoc-code .gr{color:#E40000}.pdoc-code .gh{color:#000080; font-weight:bold}.pdoc-code .gi{color:#008400}.pdoc-code .go{color:#717171}.pdoc-code .gp{color:#000080; font-weight:bold}.pdoc-code .gs{font-weight:bold}.pdoc-code .gu{color:#800080; font-weight:bold}.pdoc-code .gt{color:#0044DD}.pdoc-code .kc{color:#008000; font-weight:bold}.pdoc-code .kd{color:#008000; font-weight:bold}.pdoc-code .kn{color:#008000; font-weight:bold}.pdoc-code .kp{color:#008000}.pdoc-code .kr{color:#008000; font-weight:bold}.pdoc-code .kt{color:#B00040}.pdoc-code .m{color:#666666}.pdoc-code .s{color:#BA2121}.pdoc-code .na{color:#687822}.pdoc-code .nb{color:#008000}.pdoc-code .nc{color:#0000FF; font-weight:bold}.pdoc-code .no{color:#880000}.pdoc-code .nd{color:#AA22FF}.pdoc-code .ni{color:#717171; font-weight:bold}.pdoc-code .ne{color:#CB3F38; font-weight:bold}.pdoc-code .nf{color:#0000FF}.pdoc-code .nl{color:#767600}.pdoc-code .nn{color:#0000FF; font-weight:bold}.pdoc-code .nt{color:#008000; font-weight:bold}.pdoc-code .nv{color:#19177C}.pdoc-code .ow{color:#AA22FF; font-weight:bold}.pdoc-code .w{color:#bbbbbb}.pdoc-code .mb{color:#666666}.pdoc-code .mf{color:#666666}.pdoc-code .mh{color:#666666}.pdoc-code .mi{color:#666666}.pdoc-code .mo{color:#666666}.pdoc-code .sa{color:#BA2121}.pdoc-code .sb{color:#BA2121}.pdoc-code .sc{color:#BA2121}.pdoc-code .dl{color:#BA2121}.pdoc-code .sd{color:#BA2121; font-style:italic}.pdoc-code .s2{color:#BA2121}.pdoc-code .se{color:#AA5D1F; font-weight:bold}.pdoc-code .sh{color:#BA2121}.pdoc-code .si{color:#A45A77; font-weight:bold}.pdoc-code .sx{color:#008000}.pdoc-code .sr{color:#A45A77}.pdoc-code .s1{color:#BA2121}.pdoc-code .ss{color:#19177C}.pdoc-code .bp{color:#008000}.pdoc-code .fm{color:#0000FF}.pdoc-code .vc{color:#19177C}.pdoc-code .vg{color:#19177C}.pdoc-code .vi{color:#19177C}.pdoc-code .vm{color:#19177C}.pdoc-code .il{color:#666666}</style> <style>/*! theme.css */:root{--pdoc-background:#fff;}.pdoc{--text:#212529;--muted:#6c757d;--link:#3660a5;--link-hover:#1659c5;--code:#f8f8f8;--active:#fff598;--accent:#eee;--accent2:#c1c1c1;--nav-hover:rgba(255, 255, 255, 0.5);--name:#0066BB;--def:#008800;--annotation:#007020;}</style> <style>/*! layout.css */html, body{width:100%;height:100%;}html, main{scroll-behavior:smooth;}body{background-color:var(--pdoc-background);}@media (max-width:769px){#navtoggle{cursor:pointer;position:absolute;width:50px;height:40px;top:1rem;right:1rem;border-color:var(--text);color:var(--text);display:flex;opacity:0.8;z-index:999;}#navtoggle:hover{opacity:1;}#togglestate + div{display:none;}#togglestate:checked + div{display:inherit;}main, header{padding:2rem 3vw;}header + main{margin-top:-3rem;}.git-button{display:none !important;}nav input[type="search"]{max-width:77%;}nav input[type="search"]:first-child{margin-top:-6px;}nav input[type="search"]:valid ~ *{display:none !important;}}@media (min-width:770px){:root{--sidebar-width:clamp(12.5rem, 28vw, 22rem);}nav{position:fixed;overflow:auto;height:100vh;width:var(--sidebar-width);}main, header{padding:3rem 2rem 3rem calc(var(--sidebar-width) + 3rem);width:calc(54rem + var(--sidebar-width));max-width:100%;}header + main{margin-top:-4rem;}#navtoggle{display:none;}}#togglestate{position:absolute;height:0;opacity:0;}nav.pdoc{--pad:clamp(0.5rem, 2vw, 1.75rem);--indent:1.5rem;background-color:var(--accent);border-right:1px solid var(--accent2);box-shadow:0 0 20px rgba(50, 50, 50, .2) inset;padding:0 0 0 var(--pad);overflow-wrap:anywhere;scrollbar-width:thin; scrollbar-color:var(--accent2) transparent; z-index:1}nav.pdoc::-webkit-scrollbar{width:.4rem; }nav.pdoc::-webkit-scrollbar-thumb{background-color:var(--accent2); }nav.pdoc > div{padding:var(--pad) 0;}nav.pdoc .module-list-button{display:inline-flex;align-items:center;color:var(--text);border-color:var(--muted);margin-bottom:1rem;}nav.pdoc .module-list-button:hover{border-color:var(--text);}nav.pdoc input[type=search]{display:block;outline-offset:0;width:calc(100% - var(--pad));}nav.pdoc .logo{max-width:calc(100% - var(--pad));max-height:35vh;display:block;margin:0 auto 1rem;transform:translate(calc(-.5 * var(--pad)), 0);}nav.pdoc ul{list-style:none;padding-left:0;}nav.pdoc > div > ul{margin-left:calc(0px - var(--pad));}nav.pdoc li a{padding:.2rem 0 .2rem calc(var(--pad) + var(--indent));}nav.pdoc > div > ul > li > a{padding-left:var(--pad);}nav.pdoc li{transition:all 100ms;}nav.pdoc li:hover{background-color:var(--nav-hover);}nav.pdoc a, nav.pdoc a:hover{color:var(--text);}nav.pdoc a{display:block;}nav.pdoc > h2:first-of-type{margin-top:1.5rem;}nav.pdoc .class:before{content:"class ";color:var(--muted);}nav.pdoc .function:after{content:"()";color:var(--muted);}nav.pdoc footer:before{content:"";display:block;width:calc(100% - var(--pad));border-top:solid var(--accent2) 1px;margin-top:1.5rem;padding-top:.5rem;}nav.pdoc footer{font-size:small;}</style> <style>/*! content.css */.pdoc{color:var(--text);box-sizing:border-box;line-height:1.5;background:none;}.pdoc .pdoc-button{cursor:pointer;display:inline-block;border:solid black 1px;border-radius:2px;font-size:.75rem;padding:calc(0.5em - 1px) 1em;transition:100ms all;}.pdoc .pdoc-alert{padding:1rem 1rem 1rem calc(1.5rem + 24px);border:1px solid transparent;border-radius:.25rem;background-repeat:no-repeat;background-position:1rem center;margin-bottom:1rem;}.pdoc .pdoc-alert > *:last-child{margin-bottom:0;}.pdoc .pdoc-alert-note {color:#084298;background-color:#cfe2ff;border-color:#b6d4fe;background-image:url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22%23084298%22%20viewBox%3D%220%200%2016%2016%22%3E%3Cpath%20d%3D%22M8%2016A8%208%200%201%200%208%200a8%208%200%200%200%200%2016zm.93-9.412-1%204.705c-.07.34.029.533.304.533.194%200%20.487-.07.686-.246l-.088.416c-.287.346-.92.598-1.465.598-.703%200-1.002-.422-.808-1.319l.738-3.468c.064-.293.006-.399-.287-.47l-.451-.081.082-.381%202.29-.287zM8%205.5a1%201%200%201%201%200-2%201%201%200%200%201%200%202z%22/%3E%3C/svg%3E");}.pdoc .pdoc-alert-warning{color:#664d03;background-color:#fff3cd;border-color:#ffecb5;background-image:url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22%23664d03%22%20viewBox%3D%220%200%2016%2016%22%3E%3Cpath%20d%3D%22M8.982%201.566a1.13%201.13%200%200%200-1.96%200L.165%2013.233c-.457.778.091%201.767.98%201.767h13.713c.889%200%201.438-.99.98-1.767L8.982%201.566zM8%205c.535%200%20.954.462.9.995l-.35%203.507a.552.552%200%200%201-1.1%200L7.1%205.995A.905.905%200%200%201%208%205zm.002%206a1%201%200%201%201%200%202%201%201%200%200%201%200-2z%22/%3E%3C/svg%3E");}.pdoc .pdoc-alert-danger{color:#842029;background-color:#f8d7da;border-color:#f5c2c7;background-image:url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2224%22%20height%3D%2224%22%20fill%3D%22%23842029%22%20viewBox%3D%220%200%2016%2016%22%3E%3Cpath%20d%3D%22M5.52.359A.5.5%200%200%201%206%200h4a.5.5%200%200%201%20.474.658L8.694%206H12.5a.5.5%200%200%201%20.395.807l-7%209a.5.5%200%200%201-.873-.454L6.823%209.5H3.5a.5.5%200%200%201-.48-.641l2.5-8.5z%22/%3E%3C/svg%3E");}.pdoc .visually-hidden{position:absolute !important;width:1px !important;height:1px !important;padding:0 !important;margin:-1px !important;overflow:hidden !important;clip:rect(0, 0, 0, 0) !important;white-space:nowrap !important;border:0 !important;}.pdoc h1, .pdoc h2, .pdoc h3{font-weight:300;margin:.3em 0;padding:.2em 0;}.pdoc > section:not(.module-info) h1{font-size:1.5rem;font-weight:500;}.pdoc > section:not(.module-info) h2{font-size:1.4rem;font-weight:500;}.pdoc > section:not(.module-info) h3{font-size:1.3rem;font-weight:500;}.pdoc > section:not(.module-info) h4{font-size:1.2rem;}.pdoc > section:not(.module-info) h5{font-size:1.1rem;}.pdoc a{text-decoration:none;color:var(--link);}.pdoc a:hover{color:var(--link-hover);}.pdoc blockquote{margin-left:2rem;}.pdoc pre{border-top:1px solid var(--accent2);border-bottom:1px solid var(--accent2);margin-top:0;margin-bottom:1em;padding:.5rem 0 .5rem .5rem;overflow-x:auto;background-color:var(--code);}.pdoc code{color:var(--text);padding:.2em .4em;margin:0;font-size:85%;background-color:var(--accent);border-radius:6px;}.pdoc a > code{color:inherit;}.pdoc pre > code{display:inline-block;font-size:inherit;background:none;border:none;padding:0;}.pdoc > section:not(.module-info){margin-bottom:1.5rem;}.pdoc .modulename{margin-top:0;font-weight:bold;}.pdoc .modulename a{color:var(--link);transition:100ms all;}.pdoc .git-button{float:right;border:solid var(--link) 1px;}.pdoc .git-button:hover{background-color:var(--link);color:var(--pdoc-background);}.view-source-toggle-state,.view-source-toggle-state ~ .pdoc-code{display:none;}.view-source-toggle-state:checked ~ .pdoc-code{display:block;}.view-source-button{display:inline-block;float:right;font-size:.75rem;line-height:1.5rem;color:var(--muted);padding:0 .4rem 0 1.3rem;cursor:pointer;text-indent:-2px;}.view-source-button > span{visibility:hidden;}.module-info .view-source-button{float:none;display:flex;justify-content:flex-end;margin:-1.2rem .4rem -.2rem 0;}.view-source-button::before{position:absolute;content:"View Source";display:list-item;list-style-type:disclosure-closed;}.view-source-toggle-state:checked ~ .attr .view-source-button::before,.view-source-toggle-state:checked ~ .view-source-button::before{list-style-type:disclosure-open;}.pdoc .docstring{margin-bottom:1.5rem;}.pdoc section:not(.module-info) .docstring{margin-left:clamp(0rem, 5vw - 2rem, 1rem);}.pdoc .docstring .pdoc-code{margin-left:1em;margin-right:1em;}.pdoc h1:target,.pdoc h2:target,.pdoc h3:target,.pdoc h4:target,.pdoc h5:target,.pdoc h6:target,.pdoc .pdoc-code > pre > span:target{background-color:var(--active);box-shadow:-1rem 0 0 0 var(--active);}.pdoc .pdoc-code > pre > span:target{display:block;}.pdoc div:target > .attr,.pdoc section:target > .attr,.pdoc dd:target > a{background-color:var(--active);}.pdoc *{scroll-margin:2rem;}.pdoc .pdoc-code .linenos{user-select:none;}.pdoc .attr:hover{filter:contrast(0.95);}.pdoc section, .pdoc .classattr{position:relative;}.pdoc .headerlink{--width:clamp(1rem, 3vw, 2rem);position:absolute;top:0;left:calc(0rem - var(--width));transition:all 100ms ease-in-out;opacity:0;}.pdoc .headerlink::before{content:"#";display:block;text-align:center;width:var(--width);height:2.3rem;line-height:2.3rem;font-size:1.5rem;}.pdoc .attr:hover ~ .headerlink,.pdoc *:target > .headerlink,.pdoc .headerlink:hover{opacity:1;}.pdoc .attr{display:block;margin:.5rem 0 .5rem;padding:.4rem .4rem .4rem 1rem;background-color:var(--accent);overflow-x:auto;}.pdoc .classattr{margin-left:2rem;}.pdoc .name{color:var(--name);font-weight:bold;}.pdoc .def{color:var(--def);font-weight:bold;}.pdoc .signature{background-color:transparent;}.pdoc .param, .pdoc .return-annotation{white-space:pre;}.pdoc .signature.multiline .param{display:block;}.pdoc .signature.condensed .param{display:inline-block;}.pdoc .annotation{color:var(--annotation);}.pdoc .view-value-toggle-state,.pdoc .view-value-toggle-state ~ .default_value{display:none;}.pdoc .view-value-toggle-state:checked ~ .default_value{display:inherit;}.pdoc .view-value-button{font-size:.5rem;vertical-align:middle;border-style:dashed;margin-top:-0.1rem;}.pdoc .view-value-button:hover{background:white;}.pdoc .view-value-button::before{content:"show";text-align:center;width:2.2em;display:inline-block;}.pdoc .view-value-toggle-state:checked ~ .view-value-button::before{content:"hide";}.pdoc .inherited{margin-left:2rem;}.pdoc .inherited dt{font-weight:700;}.pdoc .inherited dt, .pdoc .inherited dd{display:inline;margin-left:0;margin-bottom:.5rem;}.pdoc .inherited dd:not(:last-child):after{content:", ";}.pdoc .inherited .class:before{content:"class ";}.pdoc .inherited .function a:after{content:"()";}.pdoc .search-result .docstring{overflow:auto;max-height:25vh;}.pdoc .search-result.focused > .attr{background-color:var(--active);}.pdoc .attribution{margin-top:2rem;display:block;opacity:0.5;transition:all 200ms;filter:grayscale(100%);}.pdoc .attribution:hover{opacity:1;filter:grayscale(0%);}.pdoc .attribution img{margin-left:5px;height:35px;vertical-align:middle;width:70px;transition:all 200ms;}.pdoc table{display:block;width:max-content;max-width:100%;overflow:auto;margin-bottom:1rem;}.pdoc table th{font-weight:600;}.pdoc table th, .pdoc table td{padding:6px 13px;border:1px solid var(--accent2);}</style> <style>/*! custom.css */</style></head> <body> <nav class="pdoc"> <label id="navtoggle" for="togglestate" class="pdoc-button"><svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'><path stroke-linecap='round' stroke="currentColor" stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/></svg></label> <input id="togglestate" type="checkbox" aria-hidden="true" tabindex="-1"> <div> <a class="pdoc-button module-list-button" href="../control.html"> <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-box-arrow-in-left" viewBox="0 0 16 16"> <path fill-rule="evenodd" d="M10 3.5a.5.5 0 0 0-.5-.5h-8a.5.5 0 0 0-.5.5v9a.5.5 0 0 0 .5.5h8a.5.5 0 0 0 .5-.5v-2a.5.5 0 0 1 1 0v2A1.5 1.5 0 0 1 9.5 14h-8A1.5 1.5 0 0 1 0 12.5v-9A1.5 1.5 0 0 1 1.5 2h8A1.5 1.5 0 0 1 11 3.5v2a.5.5 0 0 1-1 0v-2z"/> <path fill-rule="evenodd" d="M4.146 8.354a.5.5 0 0 1 0-.708l3-3a.5.5 0 1 1 .708.708L5.707 7.5H14.5a.5.5 0 0 1 0 1H5.707l2.147 2.146a.5.5 0 0 1-.708.708l-3-3z"/> </svg>  pinecone.control</a> <input type="search" placeholder="Search..." role="searchbox" aria-label="search" pattern=".+" required> <h2>API Documentation</h2> <ul class="memberlist"> <li> <a class="class" href="#PineconeAsyncio">PineconeAsyncio</a> <ul class="memberlist"> <li> <a class="function" href="#PineconeAsyncio.__init__">PineconeAsyncio</a> </li> <li> <a class="function" href="#PineconeAsyncio.close">close</a> </li> <li> <a class="variable" href="#PineconeAsyncio.inference">inference</a> </li> <li> <a class="function" href="#PineconeAsyncio.create_index">create_index</a> </li> <li> <a class="function" href="#PineconeAsyncio.create_index_for_model">create_index_for_model</a> </li> <li> <a class="function" href="#PineconeAsyncio.delete_index">delete_index</a> </li> <li> <a class="function" href="#PineconeAsyncio.list_indexes">list_indexes</a> </li> <li> <a class="function" href="#PineconeAsyncio.describe_index">describe_index</a> </li> <li> <a class="function" href="#PineconeAsyncio.has_index">has_index</a> </li> <li> <a class="function" href="#PineconeAsyncio.configure_index">configure_index</a> </li> <li> <a class="function" href="#PineconeAsyncio.create_collection">create_collection</a> </li> <li> <a class="function" href="#PineconeAsyncio.list_collections">list_collections</a> </li> <li> <a class="function" href="#PineconeAsyncio.delete_collection">delete_collection</a> </li> <li> <a class="function" href="#PineconeAsyncio.describe_collection">describe_collection</a> </li> <li> <a class="function" href="#PineconeAsyncio.IndexAsyncio">IndexAsyncio</a> </li> </ul> </li> </ul> <a class="attribution" title="pdoc: Python API documentation generator" href="https://pdoc.dev" target="_blank"> built with pdoc<img alt="pdoc logo" src="data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20role%3D%22img%22%20aria-label%3D%22pdoc%20logo%22%20width%3D%22300%22%20height%3D%22150%22%20viewBox%3D%22-1%200%2060%2030%22%3E%3Ctitle%3Epdoc%3C/title%3E%3Cpath%20d%3D%22M29.621%2021.293c-.011-.273-.214-.475-.511-.481a.5.5%200%200%200-.489.503l-.044%201.393c-.097.551-.695%201.215-1.566%201.704-.577.428-1.306.486-2.193.182-1.426-.617-2.467-1.654-3.304-2.487l-.173-.172a3.43%203.43%200%200%200-.365-.306.49.49%200%200%200-.286-.196c-1.718-1.06-4.931-1.47-7.353.191l-.219.15c-1.707%201.187-3.413%202.131-4.328%201.03-.02-.027-.49-.685-.141-1.763.233-.721.546-2.408.772-4.076.042-.09.067-.187.046-.288.166-1.347.277-2.625.241-3.351%201.378-1.008%202.271-2.586%202.271-4.362%200-.976-.272-1.935-.788-2.774-.057-.094-.122-.18-.184-.268.033-.167.052-.339.052-.516%200-1.477-1.202-2.679-2.679-2.679-.791%200-1.496.352-1.987.9a6.3%206.3%200%200%200-1.001.029c-.492-.564-1.207-.929-2.012-.929-1.477%200-2.679%201.202-2.679%202.679A2.65%202.65%200%200%200%20.97%206.554c-.383.747-.595%201.572-.595%202.41%200%202.311%201.507%204.29%203.635%205.107-.037.699-.147%202.27-.423%203.294l-.137.461c-.622%202.042-2.515%208.257%201.727%2010.643%201.614.908%203.06%201.248%204.317%201.248%202.665%200%204.492-1.524%205.322-2.401%201.476-1.559%202.886-1.854%206.491.82%201.877%201.393%203.514%201.753%204.861%201.068%202.223-1.713%202.811-3.867%203.399-6.374.077-.846.056-1.469.054-1.537zm-4.835%204.313c-.054.305-.156.586-.242.629-.034-.007-.131-.022-.307-.157-.145-.111-.314-.478-.456-.908.221.121.432.25.675.355.115.039.219.051.33.081zm-2.251-1.238c-.05.33-.158.648-.252.694-.022.001-.125-.018-.307-.157-.217-.166-.488-.906-.639-1.573.358.344.754.693%201.198%201.036zm-3.887-2.337c-.006-.116-.018-.231-.041-.342.635.145%201.189.368%201.599.625.097.231.166.481.174.642-.03.049-.055.101-.067.158-.046.013-.128.026-.298.004-.278-.037-.901-.57-1.367-1.087zm-1.127-.497c.116.306.176.625.12.71-.019.014-.117.045-.345.016-.206-.027-.604-.332-.986-.695.41-.051.816-.056%201.211-.031zm-4.535%201.535c.209.22.379.47.358.598-.006.041-.088.138-.351.234-.144.055-.539-.063-.979-.259a11.66%2011.66%200%200%200%20.972-.573zm.983-.664c.359-.237.738-.418%201.126-.554.25.237.479.548.457.694-.006.042-.087.138-.351.235-.174.064-.694-.105-1.232-.375zm-3.381%201.794c-.022.145-.061.29-.149.401-.133.166-.358.248-.69.251h-.002c-.133%200-.306-.26-.45-.621.417.091.854.07%201.291-.031zm-2.066-8.077a4.78%204.78%200%200%201-.775-.584c.172-.115.505-.254.88-.378l-.105.962zm-.331%202.302a10.32%2010.32%200%200%201-.828-.502c.202-.143.576-.328.984-.49l-.156.992zm-.45%202.157l-.701-.403c.214-.115.536-.249.891-.376a11.57%2011.57%200%200%201-.19.779zm-.181%201.716c.064.398.194.702.298.893-.194-.051-.435-.162-.736-.398.061-.119.224-.3.438-.495zM8.87%204.141c0%20.152-.123.276-.276.276s-.275-.124-.275-.276.123-.276.276-.276.275.124.275.276zm-.735-.389a1.15%201.15%200%200%200-.314.783%201.16%201.16%200%200%200%201.162%201.162c.457%200%20.842-.27%201.032-.653.026.117.042.238.042.362a1.68%201.68%200%200%201-1.679%201.679%201.68%201.68%200%200%201-1.679-1.679c0-.843.626-1.535%201.436-1.654zM5.059%205.406A1.68%201.68%200%200%201%203.38%207.085a1.68%201.68%200%200%201-1.679-1.679c0-.037.009-.072.011-.109.21.3.541.508.935.508a1.16%201.16%200%200%200%201.162-1.162%201.14%201.14%200%200%200-.474-.912c.015%200%20.03-.005.045-.005.926.001%201.679.754%201.679%201.68zM3.198%204.141c0%20.152-.123.276-.276.276s-.275-.124-.275-.276.123-.276.276-.276.275.124.275.276zM1.375%208.964c0-.52.103-1.035.288-1.52.466.394%201.06.64%201.717.64%201.144%200%202.116-.725%202.499-1.738.383%201.012%201.355%201.738%202.499%201.738.867%200%201.631-.421%202.121-1.062.307.605.478%201.267.478%201.942%200%202.486-2.153%204.51-4.801%204.51s-4.801-2.023-4.801-4.51zm24.342%2019.349c-.985.498-2.267.168-3.813-.979-3.073-2.281-5.453-3.199-7.813-.705-1.315%201.391-4.163%203.365-8.423.97-3.174-1.786-2.239-6.266-1.261-9.479l.146-.492c.276-1.02.395-2.457.444-3.268a6.11%206.11%200%200%200%201.18.115%206.01%206.01%200%200%200%202.536-.562l-.006.175c-.802.215-1.848.612-2.021%201.25-.079.295.021.601.274.837.219.203.415.364.598.501-.667.304-1.243.698-1.311%201.179-.02.144-.022.507.393.787.213.144.395.26.564.365-1.285.521-1.361.96-1.381%201.126-.018.142-.011.496.427.746l.854.489c-.473.389-.971.914-.999%201.429-.018.278.095.532.316.713.675.556%201.231.721%201.653.721.059%200%20.104-.014.158-.02.207.707.641%201.64%201.513%201.64h.013c.8-.008%201.236-.345%201.462-.626.173-.216.268-.457.325-.692.424.195.93.374%201.372.374.151%200%20.294-.021.423-.068.732-.27.944-.704.993-1.021.009-.061.003-.119.002-.179.266.086.538.147.789.147.15%200%20.294-.021.423-.069.542-.2.797-.489.914-.754.237.147.478.258.704.288.106.014.205.021.296.021.356%200%20.595-.101.767-.229.438.435%201.094.992%201.656%201.067.106.014.205.021.296.021a1.56%201.56%200%200%200%20.323-.035c.17.575.453%201.289.866%201.605.358.273.665.362.914.362a.99.99%200%200%200%20.421-.093%201.03%201.03%200%200%200%20.245-.164c.168.428.39.846.68%201.068.358.273.665.362.913.362a.99.99%200%200%200%20.421-.093c.317-.148.512-.448.639-.762.251.157.495.257.726.257.127%200%20.25-.024.37-.071.427-.17.706-.617.841-1.314.022-.015.047-.022.068-.038.067-.051.133-.104.196-.159-.443%201.486-1.107%202.761-2.086%203.257zM8.66%209.925a.5.5%200%201%200-1%200c0%20.653-.818%201.205-1.787%201.205s-1.787-.552-1.787-1.205a.5.5%200%201%200-1%200c0%201.216%201.25%202.205%202.787%202.205s2.787-.989%202.787-2.205zm4.4%2015.965l-.208.097c-2.661%201.258-4.708%201.436-6.086.527-1.542-1.017-1.88-3.19-1.844-4.198a.4.4%200%200%200-.385-.414c-.242-.029-.406.164-.414.385-.046%201.249.367%203.686%202.202%204.896.708.467%201.547.7%202.51.7%201.248%200%202.706-.392%204.362-1.174l.185-.086a.4.4%200%200%200%20.205-.527c-.089-.204-.326-.291-.527-.206zM9.547%202.292c.093.077.205.114.317.114a.5.5%200%200%200%20.318-.886L8.817.397a.5.5%200%200%200-.703.068.5.5%200%200%200%20.069.703l1.364%201.124zm-7.661-.065c.086%200%20.173-.022.253-.068l1.523-.893a.5.5%200%200%200-.506-.863l-1.523.892a.5.5%200%200%200-.179.685c.094.158.261.247.432.247z%22%20transform%3D%22matrix%28-1%200%200%201%2058%200%29%22%20fill%3D%22%233bb300%22/%3E%3Cpath%20d%3D%22M.3%2021.86V10.18q0-.46.02-.68.04-.22.18-.5.28-.54%201.34-.54%201.06%200%201.42.28.38.26.44.78.76-1.04%202.38-1.04%201.64%200%203.1%201.54%201.46%201.54%201.46%203.58%200%202.04-1.46%203.58-1.44%201.54-3.08%201.54-1.64%200-2.38-.92v4.04q0%20.46-.04.68-.02.22-.18.5-.14.3-.5.42-.36.12-.98.12-.62%200-1-.12-.36-.12-.52-.4-.14-.28-.18-.5-.02-.22-.02-.68zm3.96-9.42q-.46.54-.46%201.18%200%20.64.46%201.18.48.52%201.2.52.74%200%201.24-.52.52-.52.52-1.18%200-.66-.48-1.18-.48-.54-1.26-.54-.76%200-1.22.54zm14.741-8.36q.16-.3.54-.42.38-.12%201-.12.64%200%201.02.12.38.12.52.42.16.3.18.54.04.22.04.68v11.94q0%20.46-.04.7-.02.22-.18.5-.3.54-1.7.54-1.38%200-1.54-.98-.84.96-2.34.96-1.8%200-3.28-1.56-1.48-1.58-1.48-3.66%200-2.1%201.48-3.68%201.5-1.58%203.28-1.58%201.48%200%202.3%201v-4.2q0-.46.02-.68.04-.24.18-.52zm-3.24%2010.86q.52.54%201.26.54.74%200%201.22-.54.5-.54.5-1.18%200-.66-.48-1.22-.46-.56-1.26-.56-.8%200-1.28.56-.48.54-.48%201.2%200%20.66.52%201.2zm7.833-1.2q0-2.4%201.68-3.96%201.68-1.56%203.84-1.56%202.16%200%203.82%201.56%201.66%201.54%201.66%203.94%200%201.66-.86%202.96-.86%201.28-2.1%201.9-1.22.6-2.54.6-1.32%200-2.56-.64-1.24-.66-2.1-1.92-.84-1.28-.84-2.88zm4.18%201.44q.64.48%201.3.48.66%200%201.32-.5.66-.5.66-1.48%200-.98-.62-1.46-.62-.48-1.34-.48-.72%200-1.34.5-.62.5-.62%201.48%200%20.96.64%201.46zm11.412-1.44q0%20.84.56%201.32.56.46%201.18.46.64%200%201.18-.36.56-.38.9-.38.6%200%201.46%201.06.46.58.46%201.04%200%20.76-1.1%201.42-1.14.8-2.8.8-1.86%200-3.58-1.34-.82-.64-1.34-1.7-.52-1.08-.52-2.36%200-1.3.52-2.34.52-1.06%201.34-1.7%201.66-1.32%203.54-1.32.76%200%201.48.22.72.2%201.06.4l.32.2q.36.24.56.38.52.4.52.92%200%20.5-.42%201.14-.72%201.1-1.38%201.1-.38%200-1.08-.44-.36-.34-1.04-.34-.66%200-1.24.48-.58.48-.58%201.34z%22%20fill%3D%22green%22/%3E%3C/svg%3E"/> </a> </div> </nav> <main class="pdoc"> <section class="module-info"> <h1 class="modulename"> <a href="./../../pinecone.html">pinecone</a>.<a href="./../control.html">control</a>.pinecone_asyncio </h1> <input id="mod-pinecone_asyncio-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <label class="view-source-button" for="mod-pinecone_asyncio-view-source">View Source</label> <div class="pdoc-code codehilite"><pre><a href="#L-1"> 1</a>import logging <a href="#L-2"> 2</a>import asyncio <a href="#L-3"> 3</a>from typing import Optional, Dict, Union <a href="#L-4"> 4</a> <a href="#L-5"> 5</a>from pinecone.config import PineconeConfig, ConfigBuilder <a href="#L-6"> 6</a> <a href="#L-7"> 7</a>from pinecone.core.openapi.db_control.api.manage_indexes_api import AsyncioManageIndexesApi <a href="#L-8"> 8</a>from pinecone.openapi_support import AsyncioApiClient <a href="#L-9"> 9</a> <a href="#L-10"> 10</a>from pinecone.utils import normalize_host, setup_async_openapi_client <a href="#L-11"> 11</a>from pinecone.core.openapi.db_control import API_VERSION <a href="#L-12"> 12</a>from pinecone.models import ( <a href="#L-13"> 13</a> ServerlessSpec, <a href="#L-14"> 14</a> PodSpec, <a href="#L-15"> 15</a> IndexModel, <a href="#L-16"> 16</a> IndexList, <a href="#L-17"> 17</a> CollectionList, <a href="#L-18"> 18</a> IndexEmbed, <a href="#L-19"> 19</a>) <a href="#L-20"> 20</a>from pinecone.utils import docslinks <a href="#L-21"> 21</a> <a href="#L-22"> 22</a>from pinecone.data import _IndexAsyncio, _AsyncioInference <a href="#L-23"> 23</a>from pinecone.enums import ( <a href="#L-24"> 24</a> Metric, <a href="#L-25"> 25</a> VectorType, <a href="#L-26"> 26</a> DeletionProtection, <a href="#L-27"> 27</a> PodType, <a href="#L-28"> 28</a> CloudProvider, <a href="#L-29"> 29</a> AwsRegion, <a href="#L-30"> 30</a> GcpRegion, <a href="#L-31"> 31</a> AzureRegion, <a href="#L-32"> 32</a>) <a href="#L-33"> 33</a>from .types import CreateIndexForModelEmbedTypedDict <a href="#L-34"> 34</a>from .request_factory import PineconeDBControlRequestFactory <a href="#L-35"> 35</a>from .pinecone_interface_asyncio import PineconeAsyncioDBControlInterface <a href="#L-36"> 36</a>from .pinecone import check_realistic_host <a href="#L-37"> 37</a> <a href="#L-38"> 38</a>logger = logging.getLogger(__name__) <a href="#L-39"> 39</a>""" @private """ <a href="#L-40"> 40</a> <a href="#L-41"> 41</a> <a href="#L-42"> 42</a>class PineconeAsyncio(PineconeAsyncioDBControlInterface): <a href="#L-43"> 43</a> """ <a href="#L-44"> 44</a> `PineconeAsyncio` is an asyncio client for interacting with Pinecone's control plane API. <a href="#L-45"> 45</a> <a href="#L-46"> 46</a> This class implements methods for managing and interacting with Pinecone resources <a href="#L-47"> 47</a> such as collections and indexes. <a href="#L-48"> 48</a> <a href="#L-49"> 49</a> To perform data operations such as inserting and querying vectors, use the `IndexAsyncio` class. <a href="#L-50"> 50</a> <a href="#L-51"> 51</a> ```python <a href="#L-52"> 52</a> import asyncio <a href="#L-53"> 53</a> from pinecone import Pinecone <a href="#L-54"> 54</a> <a href="#L-55"> 55</a> async def main(): <a href="#L-56"> 56</a> pc = Pinecone() <a href="#L-57"> 57</a> async with pc.IndexAsyncio(host="my-index.pinecone.io") as idx: <a href="#L-58"> 58</a> await idx.upsert(vectors=[(1, [1, 2, 3]), (2, [4, 5, 6])]) <a href="#L-59"> 59</a> <a href="#L-60"> 60</a> asyncio.run(main()) <a href="#L-61"> 61</a> ``` <a href="#L-62"> 62</a> """ <a href="#L-63"> 63</a> <a href="#L-64"> 64</a> def __init__( <a href="#L-65"> 65</a> self, <a href="#L-66"> 66</a> api_key: Optional[str] = None, <a href="#L-67"> 67</a> host: Optional[str] = None, <a href="#L-68"> 68</a> proxy_url: Optional[str] = None, <a href="#L-69"> 69</a> # proxy_headers: Optional[Dict[str, str]] = None, <a href="#L-70"> 70</a> ssl_ca_certs: Optional[str] = None, <a href="#L-71"> 71</a> ssl_verify: Optional[bool] = None, <a href="#L-72"> 72</a> additional_headers: Optional[Dict[str, str]] = {}, <a href="#L-73"> 73</a> **kwargs, <a href="#L-74"> 74</a> ): <a href="#L-75"> 75</a> for deprecated_kwarg in {"config", "openapi_config"}: <a href="#L-76"> 76</a> if deprecated_kwarg in kwargs: <a href="#L-77"> 77</a> raise NotImplementedError( <a href="#L-78"> 78</a> f"Passing {deprecated_kwarg} is no longer supported. Please pass individual settings such as proxy_url, ssl_ca_certs, and ssl_verify directly to the Pinecone constructor as keyword arguments. See the README at {docslinks['README']} for examples." <a href="#L-79"> 79</a> ) <a href="#L-80"> 80</a> <a href="#L-81"> 81</a> for unimplemented_kwarg in {"proxy_headers"}: <a href="#L-82"> 82</a> if unimplemented_kwarg in kwargs: <a href="#L-83"> 83</a> raise NotImplementedError( <a href="#L-84"> 84</a> f"You have passed {unimplemented_kwarg} but this configuration has not been implemented for PineconeAsyncio." <a href="#L-85"> 85</a> ) <a href="#L-86"> 86</a> <a href="#L-87"> 87</a> self.config = PineconeConfig.build( <a href="#L-88"> 88</a> api_key=api_key, <a href="#L-89"> 89</a> host=host, <a href="#L-90"> 90</a> additional_headers=additional_headers, <a href="#L-91"> 91</a> proxy_url=proxy_url, <a href="#L-92"> 92</a> proxy_headers=None, <a href="#L-93"> 93</a> ssl_ca_certs=ssl_ca_certs, <a href="#L-94"> 94</a> ssl_verify=ssl_verify, <a href="#L-95"> 95</a> **kwargs, <a href="#L-96"> 96</a> ) <a href="#L-97"> 97</a> """ @private """ <a href="#L-98"> 98</a> <a href="#L-99"> 99</a> self.openapi_config = ConfigBuilder.build_openapi_config(self.config, **kwargs) <a href="#L-100">100</a> """ @private """ <a href="#L-101">101</a> <a href="#L-102">102</a> self._inference = None # Lazy initialization <a href="#L-103">103</a> """ @private """ <a href="#L-104">104</a> <a href="#L-105">105</a> self.index_api = setup_async_openapi_client( <a href="#L-106">106</a> api_client_klass=AsyncioApiClient, <a href="#L-107">107</a> api_klass=AsyncioManageIndexesApi, <a href="#L-108">108</a> config=self.config, <a href="#L-109">109</a> openapi_config=self.openapi_config, <a href="#L-110">110</a> api_version=API_VERSION, <a href="#L-111">111</a> ) <a href="#L-112">112</a> """ @private """ <a href="#L-113">113</a> <a href="#L-114">114</a> async def __aenter__(self): <a href="#L-115">115</a> return self <a href="#L-116">116</a> <a href="#L-117">117</a> async def __aexit__(self, exc_type, exc_value, traceback): <a href="#L-118">118</a> await self.close() <a href="#L-119">119</a> <a href="#L-120">120</a> async def close(self): <a href="#L-121">121</a> """Cleanup resources used by the Pinecone client. <a href="#L-122">122</a> <a href="#L-123">123</a> This method should be called when the client is no longer needed so that <a href="#L-124">124</a> it can cleanup the aioahttp session and other resources. <a href="#L-125">125</a> <a href="#L-126">126</a> After close has been called, the client instance should not be used. <a href="#L-127">127</a> <a href="#L-128">128</a> ```python <a href="#L-129">129</a> import asyncio <a href="#L-130">130</a> from pinecone import PineconeAsyncio <a href="#L-131">131</a> <a href="#L-132">132</a> async def main(): <a href="#L-133">133</a> pc = PineconeAsyncio() <a href="#L-134">134</a> desc = await pc.describe_index(name="my-index") <a href="#L-135">135</a> await pc.close() <a href="#L-136">136</a> <a href="#L-137">137</a> asyncio.run(main()) <a href="#L-138">138</a> ``` <a href="#L-139">139</a> <a href="#L-140">140</a> If you are using the client as a context manager, the close method is called automatically <a href="#L-141">141</a> when exiting. <a href="#L-142">142</a> <a href="#L-143">143</a> ```python <a href="#L-144">144</a> import asyncio <a href="#L-145">145</a> from pinecone import PineconeAsyncio <a href="#L-146">146</a> <a href="#L-147">147</a> async def main(): <a href="#L-148">148</a> async with PineconeAsyncio() as pc: <a href="#L-149">149</a> desc = await pc.describe_index(name="my-index") <a href="#L-150">150</a> <a href="#L-151">151</a> # No need to call close in this case because the "async with" syntax <a href="#L-152">152</a> # automatically calls close when exiting the block. <a href="#L-153">153</a> asyncio.run(main()) <a href="#L-154">154</a> ``` <a href="#L-155">155</a> <a href="#L-156">156</a> """ <a href="#L-157">157</a> await self.index_api.api_client.close() <a href="#L-158">158</a> <a href="#L-159">159</a> @property <a href="#L-160">160</a> def inference(self): <a href="#L-161">161</a> """Dynamically create and cache the Inference instance.""" <a href="#L-162">162</a> if self._inference is None: <a href="#L-163">163</a> self._inference = _AsyncioInference(api_client=self.index_api.api_client) <a href="#L-164">164</a> return self._inference <a href="#L-165">165</a> <a href="#L-166">166</a> async def create_index( <a href="#L-167">167</a> self, <a href="#L-168">168</a> name: str, <a href="#L-169">169</a> spec: Union[Dict, ServerlessSpec, PodSpec], <a href="#L-170">170</a> dimension: Optional[int] = None, <a href="#L-171">171</a> metric: Optional[Union[Metric, str]] = Metric.COSINE, <a href="#L-172">172</a> timeout: Optional[int] = None, <a href="#L-173">173</a> deletion_protection: Optional[Union[DeletionProtection, str]] = DeletionProtection.DISABLED, <a href="#L-174">174</a> vector_type: Optional[Union[VectorType, str]] = VectorType.DENSE, <a href="#L-175">175</a> tags: Optional[Dict[str, str]] = None, <a href="#L-176">176</a> ) -> IndexModel: <a href="#L-177">177</a> req = PineconeDBControlRequestFactory.create_index_request( <a href="#L-178">178</a> name=name, <a href="#L-179">179</a> spec=spec, <a href="#L-180">180</a> dimension=dimension, <a href="#L-181">181</a> metric=metric, <a href="#L-182">182</a> deletion_protection=deletion_protection, <a href="#L-183">183</a> vector_type=vector_type, <a href="#L-184">184</a> tags=tags, <a href="#L-185">185</a> ) <a href="#L-186">186</a> resp = await self.index_api.create_index(create_index_request=req) <a href="#L-187">187</a> <a href="#L-188">188</a> if timeout == -1: <a href="#L-189">189</a> return IndexModel(resp) <a href="#L-190">190</a> return await self.__poll_describe_index_until_ready(name, timeout) <a href="#L-191">191</a> <a href="#L-192">192</a> async def create_index_for_model( <a href="#L-193">193</a> self, <a href="#L-194">194</a> name: str, <a href="#L-195">195</a> cloud: Union[CloudProvider, str], <a href="#L-196">196</a> region: Union[AwsRegion, GcpRegion, AzureRegion, str], <a href="#L-197">197</a> embed: Union[IndexEmbed, CreateIndexForModelEmbedTypedDict], <a href="#L-198">198</a> tags: Optional[Dict[str, str]] = None, <a href="#L-199">199</a> deletion_protection: Optional[Union[DeletionProtection, str]] = DeletionProtection.DISABLED, <a href="#L-200">200</a> timeout: Optional[int] = None, <a href="#L-201">201</a> ) -> IndexModel: <a href="#L-202">202</a> req = PineconeDBControlRequestFactory.create_index_for_model_request( <a href="#L-203">203</a> name=name, <a href="#L-204">204</a> cloud=cloud, <a href="#L-205">205</a> region=region, <a href="#L-206">206</a> embed=embed, <a href="#L-207">207</a> tags=tags, <a href="#L-208">208</a> deletion_protection=deletion_protection, <a href="#L-209">209</a> ) <a href="#L-210">210</a> resp = await self.index_api.create_index_for_model(req) <a href="#L-211">211</a> <a href="#L-212">212</a> if timeout == -1: <a href="#L-213">213</a> return IndexModel(resp) <a href="#L-214">214</a> return await self.__poll_describe_index_until_ready(name, timeout) <a href="#L-215">215</a> <a href="#L-216">216</a> async def __poll_describe_index_until_ready(self, name: str, timeout: Optional[int] = None): <a href="#L-217">217</a> description = None <a href="#L-218">218</a> <a href="#L-219">219</a> async def is_ready() -> bool: <a href="#L-220">220</a> nonlocal description <a href="#L-221">221</a> description = await self.describe_index(name=name) <a href="#L-222">222</a> return description.status.ready <a href="#L-223">223</a> <a href="#L-224">224</a> total_wait_time = 0 <a href="#L-225">225</a> if timeout is None: <a href="#L-226">226</a> # Wait indefinitely <a href="#L-227">227</a> while not await is_ready(): <a href="#L-228">228</a> logger.debug( <a href="#L-229">229</a> f"Waiting for index {name} to be ready. Total wait time {total_wait_time} seconds." <a href="#L-230">230</a> ) <a href="#L-231">231</a> total_wait_time += 5 <a href="#L-232">232</a> await asyncio.sleep(5) <a href="#L-233">233</a> <a href="#L-234">234</a> else: <a href="#L-235">235</a> # Wait for a maximum of timeout seconds <a href="#L-236">236</a> while not await is_ready(): <a href="#L-237">237</a> if timeout < 0: <a href="#L-238">238</a> logger.error(f"Index {name} is not ready. Timeout reached.") <a href="#L-239">239</a> link = docslinks["API_DESCRIBE_INDEX"] <a href="#L-240">240</a> timeout_msg = ( <a href="#L-241">241</a> f"Please call describe_index() to confirm index status. See docs at {link}" <a href="#L-242">242</a> ) <a href="#L-243">243</a> raise TimeoutError(timeout_msg) <a href="#L-244">244</a> <a href="#L-245">245</a> logger.debug( <a href="#L-246">246</a> f"Waiting for index {name} to be ready. Total wait time: {total_wait_time}" <a href="#L-247">247</a> ) <a href="#L-248">248</a> total_wait_time += 5 <a href="#L-249">249</a> await asyncio.sleep(5) <a href="#L-250">250</a> timeout -= 5 <a href="#L-251">251</a> <a href="#L-252">252</a> return description <a href="#L-253">253</a> <a href="#L-254">254</a> async def delete_index(self, name: str, timeout: Optional[int] = None): <a href="#L-255">255</a> await self.index_api.delete_index(name) <a href="#L-256">256</a> <a href="#L-257">257</a> if timeout == -1: <a href="#L-258">258</a> return <a href="#L-259">259</a> <a href="#L-260">260</a> if timeout is None: <a href="#L-261">261</a> while await self.has_index(name): <a href="#L-262">262</a> await asyncio.sleep(5) <a href="#L-263">263</a> else: <a href="#L-264">264</a> while await self.has_index(name) and timeout >= 0: <a href="#L-265">265</a> await asyncio.sleep(5) <a href="#L-266">266</a> timeout -= 5 <a href="#L-267">267</a> if timeout and timeout < 0: <a href="#L-268">268</a> raise ( <a href="#L-269">269</a> TimeoutError( <a href="#L-270">270</a> "Please call the list_indexes API ({}) to confirm if index is deleted".format( <a href="#L-271">271</a> "https://www.pinecone.io/docs/api/operation/list_indexes/" <a href="#L-272">272</a> ) <a href="#L-273">273</a> ) <a href="#L-274">274</a> ) <a href="#L-275">275</a> <a href="#L-276">276</a> async def list_indexes(self) -> IndexList: <a href="#L-277">277</a> response = await self.index_api.list_indexes() <a href="#L-278">278</a> return IndexList(response) <a href="#L-279">279</a> <a href="#L-280">280</a> async def describe_index(self, name: str) -> IndexModel: <a href="#L-281">281</a> description = await self.index_api.describe_index(name) <a href="#L-282">282</a> return IndexModel(description) <a href="#L-283">283</a> <a href="#L-284">284</a> async def has_index(self, name: str) -> bool: <a href="#L-285">285</a> available_indexes = await self.list_indexes() <a href="#L-286">286</a> if name in available_indexes.names(): <a href="#L-287">287</a> return True <a href="#L-288">288</a> else: <a href="#L-289">289</a> return False <a href="#L-290">290</a> <a href="#L-291">291</a> async def configure_index( <a href="#L-292">292</a> self, <a href="#L-293">293</a> name: str, <a href="#L-294">294</a> replicas: Optional[int] = None, <a href="#L-295">295</a> pod_type: Optional[Union[PodType, str]] = None, <a href="#L-296">296</a> deletion_protection: Optional[Union[DeletionProtection, str]] = None, <a href="#L-297">297</a> tags: Optional[Dict[str, str]] = None, <a href="#L-298">298</a> ): <a href="#L-299">299</a> description = await self.describe_index(name=name) <a href="#L-300">300</a> <a href="#L-301">301</a> req = PineconeDBControlRequestFactory.configure_index_request( <a href="#L-302">302</a> description=description, <a href="#L-303">303</a> replicas=replicas, <a href="#L-304">304</a> pod_type=pod_type, <a href="#L-305">305</a> deletion_protection=deletion_protection, <a href="#L-306">306</a> tags=tags, <a href="#L-307">307</a> ) <a href="#L-308">308</a> await self.index_api.configure_index(name, configure_index_request=req) <a href="#L-309">309</a> <a href="#L-310">310</a> async def create_collection(self, name: str, source: str): <a href="#L-311">311</a> req = PineconeDBControlRequestFactory.create_collection_request(name=name, source=source) <a href="#L-312">312</a> await self.index_api.create_collection(create_collection_request=req) <a href="#L-313">313</a> <a href="#L-314">314</a> async def list_collections(self) -> CollectionList: <a href="#L-315">315</a> response = await self.index_api.list_collections() <a href="#L-316">316</a> return CollectionList(response) <a href="#L-317">317</a> <a href="#L-318">318</a> async def delete_collection(self, name: str): <a href="#L-319">319</a> await self.index_api.delete_collection(name) <a href="#L-320">320</a> <a href="#L-321">321</a> async def describe_collection(self, name: str): <a href="#L-322">322</a> return await self.index_api.describe_collection(name).to_dict() <a href="#L-323">323</a> <a href="#L-324">324</a> def IndexAsyncio(self, host: str, **kwargs) -> _IndexAsyncio: <a href="#L-325">325</a> api_key = self.config.api_key <a href="#L-326">326</a> openapi_config = self.openapi_config <a href="#L-327">327</a> <a href="#L-328">328</a> if host is None or host == "": <a href="#L-329">329</a> raise ValueError("A host must be specified") <a href="#L-330">330</a> <a href="#L-331">331</a> check_realistic_host(host) <a href="#L-332">332</a> index_host = normalize_host(host) <a href="#L-333">333</a> <a href="#L-334">334</a> return _IndexAsyncio( <a href="#L-335">335</a> host=index_host, <a href="#L-336">336</a> api_key=api_key, <a href="#L-337">337</a> openapi_config=openapi_config, <a href="#L-338">338</a> source_tag=self.config.source_tag, <a href="#L-339">339</a> **kwargs, <a href="#L-340">340</a> ) </pre></div> </section> <section id="PineconeAsyncio"> <input id="PineconeAsyncio-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr class"> class PineconeAsyncio(<a href="pinecone_interface_asyncio.html#PineconeAsyncioDBControlInterface">pinecone.control.pinecone_interface_asyncio.PineconeAsyncioDBControlInterface</a>): <label class="view-source-button" for="PineconeAsyncio-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio-43"> 43</a>class PineconeAsyncio(PineconeAsyncioDBControlInterface): <a href="#PineconeAsyncio-44"> 44</a> """ <a href="#PineconeAsyncio-45"> 45</a> `PineconeAsyncio` is an asyncio client for interacting with Pinecone's control plane API. <a href="#PineconeAsyncio-46"> 46</a> <a href="#PineconeAsyncio-47"> 47</a> This class implements methods for managing and interacting with Pinecone resources <a href="#PineconeAsyncio-48"> 48</a> such as collections and indexes. <a href="#PineconeAsyncio-49"> 49</a> <a href="#PineconeAsyncio-50"> 50</a> To perform data operations such as inserting and querying vectors, use the `IndexAsyncio` class. <a href="#PineconeAsyncio-51"> 51</a> <a href="#PineconeAsyncio-52"> 52</a> ```python <a href="#PineconeAsyncio-53"> 53</a> import asyncio <a href="#PineconeAsyncio-54"> 54</a> from pinecone import Pinecone <a href="#PineconeAsyncio-55"> 55</a> <a href="#PineconeAsyncio-56"> 56</a> async def main(): <a href="#PineconeAsyncio-57"> 57</a> pc = Pinecone() <a href="#PineconeAsyncio-58"> 58</a> async with pc.IndexAsyncio(host="my-index.pinecone.io") as idx: <a href="#PineconeAsyncio-59"> 59</a> await idx.upsert(vectors=[(1, [1, 2, 3]), (2, [4, 5, 6])]) <a href="#PineconeAsyncio-60"> 60</a> <a href="#PineconeAsyncio-61"> 61</a> asyncio.run(main()) <a href="#PineconeAsyncio-62"> 62</a> ``` <a href="#PineconeAsyncio-63"> 63</a> """ <a href="#PineconeAsyncio-64"> 64</a> <a href="#PineconeAsyncio-65"> 65</a> def __init__( <a href="#PineconeAsyncio-66"> 66</a> self, <a href="#PineconeAsyncio-67"> 67</a> api_key: Optional[str] = None, <a href="#PineconeAsyncio-68"> 68</a> host: Optional[str] = None, <a href="#PineconeAsyncio-69"> 69</a> proxy_url: Optional[str] = None, <a href="#PineconeAsyncio-70"> 70</a> # proxy_headers: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio-71"> 71</a> ssl_ca_certs: Optional[str] = None, <a href="#PineconeAsyncio-72"> 72</a> ssl_verify: Optional[bool] = None, <a href="#PineconeAsyncio-73"> 73</a> additional_headers: Optional[Dict[str, str]] = {}, <a href="#PineconeAsyncio-74"> 74</a> **kwargs, <a href="#PineconeAsyncio-75"> 75</a> ): <a href="#PineconeAsyncio-76"> 76</a> for deprecated_kwarg in {"config", "openapi_config"}: <a href="#PineconeAsyncio-77"> 77</a> if deprecated_kwarg in kwargs: <a href="#PineconeAsyncio-78"> 78</a> raise NotImplementedError( <a href="#PineconeAsyncio-79"> 79</a> f"Passing {deprecated_kwarg} is no longer supported. Please pass individual settings such as proxy_url, ssl_ca_certs, and ssl_verify directly to the Pinecone constructor as keyword arguments. See the README at {docslinks['README']} for examples." <a href="#PineconeAsyncio-80"> 80</a> ) <a href="#PineconeAsyncio-81"> 81</a> <a href="#PineconeAsyncio-82"> 82</a> for unimplemented_kwarg in {"proxy_headers"}: <a href="#PineconeAsyncio-83"> 83</a> if unimplemented_kwarg in kwargs: <a href="#PineconeAsyncio-84"> 84</a> raise NotImplementedError( <a href="#PineconeAsyncio-85"> 85</a> f"You have passed {unimplemented_kwarg} but this configuration has not been implemented for PineconeAsyncio." <a href="#PineconeAsyncio-86"> 86</a> ) <a href="#PineconeAsyncio-87"> 87</a> <a href="#PineconeAsyncio-88"> 88</a> self.config = PineconeConfig.build( <a href="#PineconeAsyncio-89"> 89</a> api_key=api_key, <a href="#PineconeAsyncio-90"> 90</a> host=host, <a href="#PineconeAsyncio-91"> 91</a> additional_headers=additional_headers, <a href="#PineconeAsyncio-92"> 92</a> proxy_url=proxy_url, <a href="#PineconeAsyncio-93"> 93</a> proxy_headers=None, <a href="#PineconeAsyncio-94"> 94</a> ssl_ca_certs=ssl_ca_certs, <a href="#PineconeAsyncio-95"> 95</a> ssl_verify=ssl_verify, <a href="#PineconeAsyncio-96"> 96</a> **kwargs, <a href="#PineconeAsyncio-97"> 97</a> ) <a href="#PineconeAsyncio-98"> 98</a> """ @private """ <a href="#PineconeAsyncio-99"> 99</a> <a href="#PineconeAsyncio-100">100</a> self.openapi_config = ConfigBuilder.build_openapi_config(self.config, **kwargs) <a href="#PineconeAsyncio-101">101</a> """ @private """ <a href="#PineconeAsyncio-102">102</a> <a href="#PineconeAsyncio-103">103</a> self._inference = None # Lazy initialization <a href="#PineconeAsyncio-104">104</a> """ @private """ <a href="#PineconeAsyncio-105">105</a> <a href="#PineconeAsyncio-106">106</a> self.index_api = setup_async_openapi_client( <a href="#PineconeAsyncio-107">107</a> api_client_klass=AsyncioApiClient, <a href="#PineconeAsyncio-108">108</a> api_klass=AsyncioManageIndexesApi, <a href="#PineconeAsyncio-109">109</a> config=self.config, <a href="#PineconeAsyncio-110">110</a> openapi_config=self.openapi_config, <a href="#PineconeAsyncio-111">111</a> api_version=API_VERSION, <a href="#PineconeAsyncio-112">112</a> ) <a href="#PineconeAsyncio-113">113</a> """ @private """ <a href="#PineconeAsyncio-114">114</a> <a href="#PineconeAsyncio-115">115</a> async def __aenter__(self): <a href="#PineconeAsyncio-116">116</a> return self <a href="#PineconeAsyncio-117">117</a> <a href="#PineconeAsyncio-118">118</a> async def __aexit__(self, exc_type, exc_value, traceback): <a href="#PineconeAsyncio-119">119</a> await self.close() <a href="#PineconeAsyncio-120">120</a> <a href="#PineconeAsyncio-121">121</a> async def close(self): <a href="#PineconeAsyncio-122">122</a> """Cleanup resources used by the Pinecone client. <a href="#PineconeAsyncio-123">123</a> <a href="#PineconeAsyncio-124">124</a> This method should be called when the client is no longer needed so that <a href="#PineconeAsyncio-125">125</a> it can cleanup the aioahttp session and other resources. <a href="#PineconeAsyncio-126">126</a> <a href="#PineconeAsyncio-127">127</a> After close has been called, the client instance should not be used. <a href="#PineconeAsyncio-128">128</a> <a href="#PineconeAsyncio-129">129</a> ```python <a href="#PineconeAsyncio-130">130</a> import asyncio <a href="#PineconeAsyncio-131">131</a> from pinecone import PineconeAsyncio <a href="#PineconeAsyncio-132">132</a> <a href="#PineconeAsyncio-133">133</a> async def main(): <a href="#PineconeAsyncio-134">134</a> pc = PineconeAsyncio() <a href="#PineconeAsyncio-135">135</a> desc = await pc.describe_index(name="my-index") <a href="#PineconeAsyncio-136">136</a> await pc.close() <a href="#PineconeAsyncio-137">137</a> <a href="#PineconeAsyncio-138">138</a> asyncio.run(main()) <a href="#PineconeAsyncio-139">139</a> ``` <a href="#PineconeAsyncio-140">140</a> <a href="#PineconeAsyncio-141">141</a> If you are using the client as a context manager, the close method is called automatically <a href="#PineconeAsyncio-142">142</a> when exiting. <a href="#PineconeAsyncio-143">143</a> <a href="#PineconeAsyncio-144">144</a> ```python <a href="#PineconeAsyncio-145">145</a> import asyncio <a href="#PineconeAsyncio-146">146</a> from pinecone import PineconeAsyncio <a href="#PineconeAsyncio-147">147</a> <a href="#PineconeAsyncio-148">148</a> async def main(): <a href="#PineconeAsyncio-149">149</a> async with PineconeAsyncio() as pc: <a href="#PineconeAsyncio-150">150</a> desc = await pc.describe_index(name="my-index") <a href="#PineconeAsyncio-151">151</a> <a href="#PineconeAsyncio-152">152</a> # No need to call close in this case because the "async with" syntax <a href="#PineconeAsyncio-153">153</a> # automatically calls close when exiting the block. <a href="#PineconeAsyncio-154">154</a> asyncio.run(main()) <a href="#PineconeAsyncio-155">155</a> ``` <a href="#PineconeAsyncio-156">156</a> <a href="#PineconeAsyncio-157">157</a> """ <a href="#PineconeAsyncio-158">158</a> await self.index_api.api_client.close() <a href="#PineconeAsyncio-159">159</a> <a href="#PineconeAsyncio-160">160</a> @property <a href="#PineconeAsyncio-161">161</a> def inference(self): <a href="#PineconeAsyncio-162">162</a> """Dynamically create and cache the Inference instance.""" <a href="#PineconeAsyncio-163">163</a> if self._inference is None: <a href="#PineconeAsyncio-164">164</a> self._inference = _AsyncioInference(api_client=self.index_api.api_client) <a href="#PineconeAsyncio-165">165</a> return self._inference <a href="#PineconeAsyncio-166">166</a> <a href="#PineconeAsyncio-167">167</a> async def create_index( <a href="#PineconeAsyncio-168">168</a> self, <a href="#PineconeAsyncio-169">169</a> name: str, <a href="#PineconeAsyncio-170">170</a> spec: Union[Dict, ServerlessSpec, PodSpec], <a href="#PineconeAsyncio-171">171</a> dimension: Optional[int] = None, <a href="#PineconeAsyncio-172">172</a> metric: Optional[Union[Metric, str]] = Metric.COSINE, <a href="#PineconeAsyncio-173">173</a> timeout: Optional[int] = None, <a href="#PineconeAsyncio-174">174</a> deletion_protection: Optional[Union[DeletionProtection, str]] = DeletionProtection.DISABLED, <a href="#PineconeAsyncio-175">175</a> vector_type: Optional[Union[VectorType, str]] = VectorType.DENSE, <a href="#PineconeAsyncio-176">176</a> tags: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio-177">177</a> ) -> IndexModel: <a href="#PineconeAsyncio-178">178</a> req = PineconeDBControlRequestFactory.create_index_request( <a href="#PineconeAsyncio-179">179</a> name=name, <a href="#PineconeAsyncio-180">180</a> spec=spec, <a href="#PineconeAsyncio-181">181</a> dimension=dimension, <a href="#PineconeAsyncio-182">182</a> metric=metric, <a href="#PineconeAsyncio-183">183</a> deletion_protection=deletion_protection, <a href="#PineconeAsyncio-184">184</a> vector_type=vector_type, <a href="#PineconeAsyncio-185">185</a> tags=tags, <a href="#PineconeAsyncio-186">186</a> ) <a href="#PineconeAsyncio-187">187</a> resp = await self.index_api.create_index(create_index_request=req) <a href="#PineconeAsyncio-188">188</a> <a href="#PineconeAsyncio-189">189</a> if timeout == -1: <a href="#PineconeAsyncio-190">190</a> return IndexModel(resp) <a href="#PineconeAsyncio-191">191</a> return await self.__poll_describe_index_until_ready(name, timeout) <a href="#PineconeAsyncio-192">192</a> <a href="#PineconeAsyncio-193">193</a> async def create_index_for_model( <a href="#PineconeAsyncio-194">194</a> self, <a href="#PineconeAsyncio-195">195</a> name: str, <a href="#PineconeAsyncio-196">196</a> cloud: Union[CloudProvider, str], <a href="#PineconeAsyncio-197">197</a> region: Union[AwsRegion, GcpRegion, AzureRegion, str], <a href="#PineconeAsyncio-198">198</a> embed: Union[IndexEmbed, CreateIndexForModelEmbedTypedDict], <a href="#PineconeAsyncio-199">199</a> tags: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio-200">200</a> deletion_protection: Optional[Union[DeletionProtection, str]] = DeletionProtection.DISABLED, <a href="#PineconeAsyncio-201">201</a> timeout: Optional[int] = None, <a href="#PineconeAsyncio-202">202</a> ) -> IndexModel: <a href="#PineconeAsyncio-203">203</a> req = PineconeDBControlRequestFactory.create_index_for_model_request( <a href="#PineconeAsyncio-204">204</a> name=name, <a href="#PineconeAsyncio-205">205</a> cloud=cloud, <a href="#PineconeAsyncio-206">206</a> region=region, <a href="#PineconeAsyncio-207">207</a> embed=embed, <a href="#PineconeAsyncio-208">208</a> tags=tags, <a href="#PineconeAsyncio-209">209</a> deletion_protection=deletion_protection, <a href="#PineconeAsyncio-210">210</a> ) <a href="#PineconeAsyncio-211">211</a> resp = await self.index_api.create_index_for_model(req) <a href="#PineconeAsyncio-212">212</a> <a href="#PineconeAsyncio-213">213</a> if timeout == -1: <a href="#PineconeAsyncio-214">214</a> return IndexModel(resp) <a href="#PineconeAsyncio-215">215</a> return await self.__poll_describe_index_until_ready(name, timeout) <a href="#PineconeAsyncio-216">216</a> <a href="#PineconeAsyncio-217">217</a> async def __poll_describe_index_until_ready(self, name: str, timeout: Optional[int] = None): <a href="#PineconeAsyncio-218">218</a> description = None <a href="#PineconeAsyncio-219">219</a> <a href="#PineconeAsyncio-220">220</a> async def is_ready() -> bool: <a href="#PineconeAsyncio-221">221</a> nonlocal description <a href="#PineconeAsyncio-222">222</a> description = await self.describe_index(name=name) <a href="#PineconeAsyncio-223">223</a> return description.status.ready <a href="#PineconeAsyncio-224">224</a> <a href="#PineconeAsyncio-225">225</a> total_wait_time = 0 <a href="#PineconeAsyncio-226">226</a> if timeout is None: <a href="#PineconeAsyncio-227">227</a> # Wait indefinitely <a href="#PineconeAsyncio-228">228</a> while not await is_ready(): <a href="#PineconeAsyncio-229">229</a> logger.debug( <a href="#PineconeAsyncio-230">230</a> f"Waiting for index {name} to be ready. Total wait time {total_wait_time} seconds." <a href="#PineconeAsyncio-231">231</a> ) <a href="#PineconeAsyncio-232">232</a> total_wait_time += 5 <a href="#PineconeAsyncio-233">233</a> await asyncio.sleep(5) <a href="#PineconeAsyncio-234">234</a> <a href="#PineconeAsyncio-235">235</a> else: <a href="#PineconeAsyncio-236">236</a> # Wait for a maximum of timeout seconds <a href="#PineconeAsyncio-237">237</a> while not await is_ready(): <a href="#PineconeAsyncio-238">238</a> if timeout < 0: <a href="#PineconeAsyncio-239">239</a> logger.error(f"Index {name} is not ready. Timeout reached.") <a href="#PineconeAsyncio-240">240</a> link = docslinks["API_DESCRIBE_INDEX"] <a href="#PineconeAsyncio-241">241</a> timeout_msg = ( <a href="#PineconeAsyncio-242">242</a> f"Please call describe_index() to confirm index status. See docs at {link}" <a href="#PineconeAsyncio-243">243</a> ) <a href="#PineconeAsyncio-244">244</a> raise TimeoutError(timeout_msg) <a href="#PineconeAsyncio-245">245</a> <a href="#PineconeAsyncio-246">246</a> logger.debug( <a href="#PineconeAsyncio-247">247</a> f"Waiting for index {name} to be ready. Total wait time: {total_wait_time}" <a href="#PineconeAsyncio-248">248</a> ) <a href="#PineconeAsyncio-249">249</a> total_wait_time += 5 <a href="#PineconeAsyncio-250">250</a> await asyncio.sleep(5) <a href="#PineconeAsyncio-251">251</a> timeout -= 5 <a href="#PineconeAsyncio-252">252</a> <a href="#PineconeAsyncio-253">253</a> return description <a href="#PineconeAsyncio-254">254</a> <a href="#PineconeAsyncio-255">255</a> async def delete_index(self, name: str, timeout: Optional[int] = None): <a href="#PineconeAsyncio-256">256</a> await self.index_api.delete_index(name) <a href="#PineconeAsyncio-257">257</a> <a href="#PineconeAsyncio-258">258</a> if timeout == -1: <a href="#PineconeAsyncio-259">259</a> return <a href="#PineconeAsyncio-260">260</a> <a href="#PineconeAsyncio-261">261</a> if timeout is None: <a href="#PineconeAsyncio-262">262</a> while await self.has_index(name): <a href="#PineconeAsyncio-263">263</a> await asyncio.sleep(5) <a href="#PineconeAsyncio-264">264</a> else: <a href="#PineconeAsyncio-265">265</a> while await self.has_index(name) and timeout >= 0: <a href="#PineconeAsyncio-266">266</a> await asyncio.sleep(5) <a href="#PineconeAsyncio-267">267</a> timeout -= 5 <a href="#PineconeAsyncio-268">268</a> if timeout and timeout < 0: <a href="#PineconeAsyncio-269">269</a> raise ( <a href="#PineconeAsyncio-270">270</a> TimeoutError( <a href="#PineconeAsyncio-271">271</a> "Please call the list_indexes API ({}) to confirm if index is deleted".format( <a href="#PineconeAsyncio-272">272</a> "https://www.pinecone.io/docs/api/operation/list_indexes/" <a href="#PineconeAsyncio-273">273</a> ) <a href="#PineconeAsyncio-274">274</a> ) <a href="#PineconeAsyncio-275">275</a> ) <a href="#PineconeAsyncio-276">276</a> <a href="#PineconeAsyncio-277">277</a> async def list_indexes(self) -> IndexList: <a href="#PineconeAsyncio-278">278</a> response = await self.index_api.list_indexes() <a href="#PineconeAsyncio-279">279</a> return IndexList(response) <a href="#PineconeAsyncio-280">280</a> <a href="#PineconeAsyncio-281">281</a> async def describe_index(self, name: str) -> IndexModel: <a href="#PineconeAsyncio-282">282</a> description = await self.index_api.describe_index(name) <a href="#PineconeAsyncio-283">283</a> return IndexModel(description) <a href="#PineconeAsyncio-284">284</a> <a href="#PineconeAsyncio-285">285</a> async def has_index(self, name: str) -> bool: <a href="#PineconeAsyncio-286">286</a> available_indexes = await self.list_indexes() <a href="#PineconeAsyncio-287">287</a> if name in available_indexes.names(): <a href="#PineconeAsyncio-288">288</a> return True <a href="#PineconeAsyncio-289">289</a> else: <a href="#PineconeAsyncio-290">290</a> return False <a href="#PineconeAsyncio-291">291</a> <a href="#PineconeAsyncio-292">292</a> async def configure_index( <a href="#PineconeAsyncio-293">293</a> self, <a href="#PineconeAsyncio-294">294</a> name: str, <a href="#PineconeAsyncio-295">295</a> replicas: Optional[int] = None, <a href="#PineconeAsyncio-296">296</a> pod_type: Optional[Union[PodType, str]] = None, <a href="#PineconeAsyncio-297">297</a> deletion_protection: Optional[Union[DeletionProtection, str]] = None, <a href="#PineconeAsyncio-298">298</a> tags: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio-299">299</a> ): <a href="#PineconeAsyncio-300">300</a> description = await self.describe_index(name=name) <a href="#PineconeAsyncio-301">301</a> <a href="#PineconeAsyncio-302">302</a> req = PineconeDBControlRequestFactory.configure_index_request( <a href="#PineconeAsyncio-303">303</a> description=description, <a href="#PineconeAsyncio-304">304</a> replicas=replicas, <a href="#PineconeAsyncio-305">305</a> pod_type=pod_type, <a href="#PineconeAsyncio-306">306</a> deletion_protection=deletion_protection, <a href="#PineconeAsyncio-307">307</a> tags=tags, <a href="#PineconeAsyncio-308">308</a> ) <a href="#PineconeAsyncio-309">309</a> await self.index_api.configure_index(name, configure_index_request=req) <a href="#PineconeAsyncio-310">310</a> <a href="#PineconeAsyncio-311">311</a> async def create_collection(self, name: str, source: str): <a href="#PineconeAsyncio-312">312</a> req = PineconeDBControlRequestFactory.create_collection_request(name=name, source=source) <a href="#PineconeAsyncio-313">313</a> await self.index_api.create_collection(create_collection_request=req) <a href="#PineconeAsyncio-314">314</a> <a href="#PineconeAsyncio-315">315</a> async def list_collections(self) -> CollectionList: <a href="#PineconeAsyncio-316">316</a> response = await self.index_api.list_collections() <a href="#PineconeAsyncio-317">317</a> return CollectionList(response) <a href="#PineconeAsyncio-318">318</a> <a href="#PineconeAsyncio-319">319</a> async def delete_collection(self, name: str): <a href="#PineconeAsyncio-320">320</a> await self.index_api.delete_collection(name) <a href="#PineconeAsyncio-321">321</a> <a href="#PineconeAsyncio-322">322</a> async def describe_collection(self, name: str): <a href="#PineconeAsyncio-323">323</a> return await self.index_api.describe_collection(name).to_dict() <a href="#PineconeAsyncio-324">324</a> <a href="#PineconeAsyncio-325">325</a> def IndexAsyncio(self, host: str, **kwargs) -> _IndexAsyncio: <a href="#PineconeAsyncio-326">326</a> api_key = self.config.api_key <a href="#PineconeAsyncio-327">327</a> openapi_config = self.openapi_config <a href="#PineconeAsyncio-328">328</a> <a href="#PineconeAsyncio-329">329</a> if host is None or host == "": <a href="#PineconeAsyncio-330">330</a> raise ValueError("A host must be specified") <a href="#PineconeAsyncio-331">331</a> <a href="#PineconeAsyncio-332">332</a> check_realistic_host(host) <a href="#PineconeAsyncio-333">333</a> index_host = normalize_host(host) <a href="#PineconeAsyncio-334">334</a> <a href="#PineconeAsyncio-335">335</a> return _IndexAsyncio( <a href="#PineconeAsyncio-336">336</a> host=index_host, <a href="#PineconeAsyncio-337">337</a> api_key=api_key, <a href="#PineconeAsyncio-338">338</a> openapi_config=openapi_config, <a href="#PineconeAsyncio-339">339</a> source_tag=self.config.source_tag, <a href="#PineconeAsyncio-340">340</a> **kwargs, <a href="#PineconeAsyncio-341">341</a> ) </pre></div> <div class="docstring"><code><a href="#PineconeAsyncio">PineconeAsyncio</a></code> is an asyncio client for interacting with Pinecone's control plane API. This class implements methods for managing and interacting with Pinecone resources such as collections and indexes. To perform data operations such as inserting and querying vectors, use the <code><a href="#PineconeAsyncio.IndexAsyncio">IndexAsyncio</a></code> class. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import Pinecone async def main(): pc = Pinecone() async with pc.IndexAsyncio(host="my-index.pinecone.io") as idx: await idx.upsert(vectors=[(1, [1, 2, 3]), (2, [4, 5, 6])]) asyncio.run(main()) </code></pre> </div> </div> <div id="PineconeAsyncio.__init__" class="classattr"> <input id="PineconeAsyncio.__init__-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> PineconeAsyncio( api_key: Optional[str] = None, host: Optional[str] = None, proxy_url: Optional[str] = None, ssl_ca_certs: Optional[str] = None, ssl_verify: Optional[bool] = None, additional_headers: Optional[Dict[str, str]] = {}, **kwargs) <label class="view-source-button" for="PineconeAsyncio.__init__-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.__init__"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.__init__-65"> 65</a> def __init__( <a href="#PineconeAsyncio.__init__-66"> 66</a> self, <a href="#PineconeAsyncio.__init__-67"> 67</a> api_key: Optional[str] = None, <a href="#PineconeAsyncio.__init__-68"> 68</a> host: Optional[str] = None, <a href="#PineconeAsyncio.__init__-69"> 69</a> proxy_url: Optional[str] = None, <a href="#PineconeAsyncio.__init__-70"> 70</a> # proxy_headers: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio.__init__-71"> 71</a> ssl_ca_certs: Optional[str] = None, <a href="#PineconeAsyncio.__init__-72"> 72</a> ssl_verify: Optional[bool] = None, <a href="#PineconeAsyncio.__init__-73"> 73</a> additional_headers: Optional[Dict[str, str]] = {}, <a href="#PineconeAsyncio.__init__-74"> 74</a> **kwargs, <a href="#PineconeAsyncio.__init__-75"> 75</a> ): <a href="#PineconeAsyncio.__init__-76"> 76</a> for deprecated_kwarg in {"config", "openapi_config"}: <a href="#PineconeAsyncio.__init__-77"> 77</a> if deprecated_kwarg in kwargs: <a href="#PineconeAsyncio.__init__-78"> 78</a> raise NotImplementedError( <a href="#PineconeAsyncio.__init__-79"> 79</a> f"Passing {deprecated_kwarg} is no longer supported. Please pass individual settings such as proxy_url, ssl_ca_certs, and ssl_verify directly to the Pinecone constructor as keyword arguments. See the README at {docslinks['README']} for examples." <a href="#PineconeAsyncio.__init__-80"> 80</a> ) <a href="#PineconeAsyncio.__init__-81"> 81</a> <a href="#PineconeAsyncio.__init__-82"> 82</a> for unimplemented_kwarg in {"proxy_headers"}: <a href="#PineconeAsyncio.__init__-83"> 83</a> if unimplemented_kwarg in kwargs: <a href="#PineconeAsyncio.__init__-84"> 84</a> raise NotImplementedError( <a href="#PineconeAsyncio.__init__-85"> 85</a> f"You have passed {unimplemented_kwarg} but this configuration has not been implemented for PineconeAsyncio." <a href="#PineconeAsyncio.__init__-86"> 86</a> ) <a href="#PineconeAsyncio.__init__-87"> 87</a> <a href="#PineconeAsyncio.__init__-88"> 88</a> self.config = PineconeConfig.build( <a href="#PineconeAsyncio.__init__-89"> 89</a> api_key=api_key, <a href="#PineconeAsyncio.__init__-90"> 90</a> host=host, <a href="#PineconeAsyncio.__init__-91"> 91</a> additional_headers=additional_headers, <a href="#PineconeAsyncio.__init__-92"> 92</a> proxy_url=proxy_url, <a href="#PineconeAsyncio.__init__-93"> 93</a> proxy_headers=None, <a href="#PineconeAsyncio.__init__-94"> 94</a> ssl_ca_certs=ssl_ca_certs, <a href="#PineconeAsyncio.__init__-95"> 95</a> ssl_verify=ssl_verify, <a href="#PineconeAsyncio.__init__-96"> 96</a> **kwargs, <a href="#PineconeAsyncio.__init__-97"> 97</a> ) <a href="#PineconeAsyncio.__init__-98"> 98</a> """ @private """ <a href="#PineconeAsyncio.__init__-99"> 99</a> <a href="#PineconeAsyncio.__init__-100">100</a> self.openapi_config = ConfigBuilder.build_openapi_config(self.config, **kwargs) <a href="#PineconeAsyncio.__init__-101">101</a> """ @private """ <a href="#PineconeAsyncio.__init__-102">102</a> <a href="#PineconeAsyncio.__init__-103">103</a> self._inference = None # Lazy initialization <a href="#PineconeAsyncio.__init__-104">104</a> """ @private """ <a href="#PineconeAsyncio.__init__-105">105</a> <a href="#PineconeAsyncio.__init__-106">106</a> self.index_api = setup_async_openapi_client( <a href="#PineconeAsyncio.__init__-107">107</a> api_client_klass=AsyncioApiClient, <a href="#PineconeAsyncio.__init__-108">108</a> api_klass=AsyncioManageIndexesApi, <a href="#PineconeAsyncio.__init__-109">109</a> config=self.config, <a href="#PineconeAsyncio.__init__-110">110</a> openapi_config=self.openapi_config, <a href="#PineconeAsyncio.__init__-111">111</a> api_version=API_VERSION, <a href="#PineconeAsyncio.__init__-112">112</a> ) <a href="#PineconeAsyncio.__init__-113">113</a> """ @private """ </pre></div> <div class="docstring">The <code><a href="#PineconeAsyncio">PineconeAsyncio</a></code> class is the main entry point for interacting with Pinecone using asyncio. It is used to create, delete, and manage your indexes and collections. Except for needing to use <code>async with</code> when instantiating the client and <code>await</code> when calling its methods, the functionality provided by this class is extremely similar to the functionality of the <code>Pinecone</code> class. <h6 id="parameters">Parameters</h6> <ul> <li>api_key: The API key to use for authentication. If not passed via kwarg, the API key will be read from the environment variable <code>PINECONE_API_KEY</code>.</li> <li>host: The control plane host to connect to.</li> <li>proxy_url: The URL of the proxy to use for the connection. Default: <code>None</code></li> <li>proxy_headers: Additional headers to pass to the proxy. Use this if your proxy setup requires authentication. Default: <code>{}</code></li> <li>ssl_ca_certs: The path to the SSL CA certificate bundle to use for the connection. This path should point to a file in PEM format. Default: <code>None</code></li> <li>ssl_verify: SSL verification is performed by default, but can be disabled using the boolean flag. Default: <code>True</code></li> <li>config: A <code>pinecone.config.Config</code> object. If passed, the <code>api_key</code> and <code>host</code> parameters will be ignored.</li> <li>additional_headers: Additional headers to pass to the API. Default: <code>{}</code></li> </ul> <h3 id="managing-the-async-context">Managing the async context</h3> The <code><a href="#PineconeAsyncio">PineconeAsyncio</a></code> class relies on an underlying <code>aiohttp</code> <code>ClientSession</code> to make asynchronous HTTP requests. To ensure that the session is properly closed, you should use the <code>async with</code> syntax when creating a <code><a href="#PineconeAsyncio">PineconeAsyncio</a></code> object. This will ensure that the session is properly closed when the context is exited. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio(api_key='YOUR_API_KEY') as pc: # Do async things index_list = await pc.list_indexes() asyncio.run(main()) </code></pre> </div> As an alternative, if you prefer to avoid code with a nested appearance and are willing to manage cleanup yourself, you can await the <code><a href="#PineconeAsyncio.close">close()</a></code> method to close the session when you are done. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): pc = PineconeAsyncio(api_key='YOUR_API_KEY') # Do async things index_list = await pc.list_indexes() # You're responsible for calling this yourself await pc.close() asyncio.run(main()) </code></pre> </div> Failing to do this may result in error messages appearing from the underlyling aiohttp library. <h3 id="configuration-with-environment-variables">Configuration with environment variables</h3> If you instantiate the Pinecone client with no arguments, it will attempt to read the API key from the environment variable <code>PINECONE_API_KEY</code>. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: # Do async things index_list = await pc.list_indexes() asyncio.run(main()) </code></pre> </div> <h3 id="configuration-with-keyword-arguments">Configuration with keyword arguments</h3> If you prefer being more explicit in your code, you can also pass the API as <h3 id="configuration-with-environment-variables-2">Configuration with environment variables</h3> If you instantiate the Pinecone client with no arguments, it will attempt to read the API key from the environment variable <code>PINECONE_API_KEY</code>. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: # Do async things index_list = await pc.list_indexes() asyncio.run(main()) </code></pre> </div> <h3 id="configuration-with-keyword-arguments-2">Configuration with keyword arguments</h3> If you prefer being more explicit in your code, you can also pass the API as <h3 id="configuration-with-environment-variables-3">Configuration with environment variables</h3> If you instantiate the Pinecone client with no arguments, it will attempt to read the API key from the environment variable <code>PINECONE_API_KEY</code>. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: # Do async things index_list = await pc.list_indexes() asyncio.run(main()) </code></pre> </div> <h3 id="configuration-with-keyword-arguments-3">Configuration with keyword arguments</h3> If you prefer being more explicit in your code, you can also pass the API as a keyword argument. <div class="pdoc-code codehilite"> <pre><code>import os import asyncio from pinecone import PineconeAsyncio async def main(): async with Pinecone(api_key=os.environ.get("PINECONE_API_KEY")) as pc: # Do async things index_list = await pc.list_indexes() asyncio.run(main()) </code></pre> </div> <h3 id="environment-variables">Environment variables</h3> The Pinecone client supports the following environment variables: <ul> <li><code>PINECONE_API_KEY</code>: The API key to use for authentication. If not passed via kwarg, the API key will be read from the environment variable <code>PINECONE_API_KEY</code>.</li> </ul> <h3 id="proxy-configuration">Proxy configuration</h3> If your network setup requires you to interact with Pinecone via a proxy, you will need to pass additional configuration using optional keyword parameters. These optional parameters are used to configure an SSL context and passed to <code>aiohttp</code>, which is the underlying library currently used by the PineconeAsyncio client to make HTTP requests. Here is a basic example: <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio( api_key='YOUR_API_KEY', proxy_url='https://your-proxy.com' ) as pc: # Do async things index_list = await pc.list_indexes() asyncio.run(main()) </code></pre> </div> <h3 id="using-proxies-with-self-signed-certificates">Using proxies with self-signed certificates</h3> By default the Pinecone Python client will perform SSL certificate verification using the CA bundle maintained by Mozilla in the <a href="https://pypi.org/project/certifi/">certifi</a> package. If your proxy server is using a self-signed certificate, you will need to pass the path to the certificate in PEM format using the <code>ssl_ca_certs</code> parameter. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio( api_key='YOUR_API_KEY', proxy_url='https://your-proxy.com', ssl_ca_certs='path/to/cert-bundle.pem' ) as pc: # Do async things await pc.list_indexes() asyncio.run(main()) </code></pre> </div> <h3 id="disabling-ssl-verification">Disabling SSL verification</h3> If you would like to disable SSL verification, you can pass the <code>ssl_verify</code> parameter with a value of <code>False</code>. We do not recommend going to production with SSL verification disabled but there are situations where this is useful such as testing with Pinecone Local running in a docker container. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio( api_key='YOUR_API_KEY', ssl_verify=False ) as pc: if not await pc.has_index('my_index'): await pc.create_index( name='my_index', dimension=1536, metric='cosine', spec=ServerlessSpec(cloud='aws', region='us-west-2') ) asyncio.run(main()) </code></pre> </div> <h3 id="passing-additional-headers">Passing additional headers</h3> If you need to pass additional headers with each request to the Pinecone API, you can do so using the <code>additional_headers</code> parameter. This is primarily for internal testing and end-users shouldn't need to do this unless specifically instructed to do so. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio( api_key='YOUR_API_KEY', host='https://api-staging.pinecone.io', additional_headers={'X-My-Header': 'my-value'} ) as pc: # Do async things await pc.list_indexes() asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.close" class="classattr"> <input id="PineconeAsyncio.close-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def close(self): <label class="view-source-button" for="PineconeAsyncio.close-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.close"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.close-121">121</a> async def close(self): <a href="#PineconeAsyncio.close-122">122</a> """Cleanup resources used by the Pinecone client. <a href="#PineconeAsyncio.close-123">123</a> <a href="#PineconeAsyncio.close-124">124</a> This method should be called when the client is no longer needed so that <a href="#PineconeAsyncio.close-125">125</a> it can cleanup the aioahttp session and other resources. <a href="#PineconeAsyncio.close-126">126</a> <a href="#PineconeAsyncio.close-127">127</a> After close has been called, the client instance should not be used. <a href="#PineconeAsyncio.close-128">128</a> <a href="#PineconeAsyncio.close-129">129</a> ```python <a href="#PineconeAsyncio.close-130">130</a> import asyncio <a href="#PineconeAsyncio.close-131">131</a> from pinecone import PineconeAsyncio <a href="#PineconeAsyncio.close-132">132</a> <a href="#PineconeAsyncio.close-133">133</a> async def main(): <a href="#PineconeAsyncio.close-134">134</a> pc = PineconeAsyncio() <a href="#PineconeAsyncio.close-135">135</a> desc = await pc.describe_index(name="my-index") <a href="#PineconeAsyncio.close-136">136</a> await pc.close() <a href="#PineconeAsyncio.close-137">137</a> <a href="#PineconeAsyncio.close-138">138</a> asyncio.run(main()) <a href="#PineconeAsyncio.close-139">139</a> ``` <a href="#PineconeAsyncio.close-140">140</a> <a href="#PineconeAsyncio.close-141">141</a> If you are using the client as a context manager, the close method is called automatically <a href="#PineconeAsyncio.close-142">142</a> when exiting. <a href="#PineconeAsyncio.close-143">143</a> <a href="#PineconeAsyncio.close-144">144</a> ```python <a href="#PineconeAsyncio.close-145">145</a> import asyncio <a href="#PineconeAsyncio.close-146">146</a> from pinecone import PineconeAsyncio <a href="#PineconeAsyncio.close-147">147</a> <a href="#PineconeAsyncio.close-148">148</a> async def main(): <a href="#PineconeAsyncio.close-149">149</a> async with PineconeAsyncio() as pc: <a href="#PineconeAsyncio.close-150">150</a> desc = await pc.describe_index(name="my-index") <a href="#PineconeAsyncio.close-151">151</a> <a href="#PineconeAsyncio.close-152">152</a> # No need to call close in this case because the "async with" syntax <a href="#PineconeAsyncio.close-153">153</a> # automatically calls close when exiting the block. <a href="#PineconeAsyncio.close-154">154</a> asyncio.run(main()) <a href="#PineconeAsyncio.close-155">155</a> ``` <a href="#PineconeAsyncio.close-156">156</a> <a href="#PineconeAsyncio.close-157">157</a> """ <a href="#PineconeAsyncio.close-158">158</a> await self.index_api.api_client.close() </pre></div> <div class="docstring">Cleanup resources used by the Pinecone client. This method should be called when the client is no longer needed so that it can cleanup the aioahttp session and other resources. After close has been called, the client instance should not be used. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): pc = PineconeAsyncio() desc = await pc.describe_index(name="my-index") await pc.close() asyncio.run(main()) </code></pre> </div> If you are using the client as a context manager, the close method is called automatically when exiting. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: desc = await pc.describe_index(name="my-index") # No need to call close in this case because the "async with" syntax # automatically calls close when exiting the block. asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.inference" class="classattr"> <input id="PineconeAsyncio.inference-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr variable"> inference <label class="view-source-button" for="PineconeAsyncio.inference-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.inference"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.inference-160">160</a> @property <a href="#PineconeAsyncio.inference-161">161</a> def inference(self): <a href="#PineconeAsyncio.inference-162">162</a> """Dynamically create and cache the Inference instance.""" <a href="#PineconeAsyncio.inference-163">163</a> if self._inference is None: <a href="#PineconeAsyncio.inference-164">164</a> self._inference = _AsyncioInference(api_client=self.index_api.api_client) <a href="#PineconeAsyncio.inference-165">165</a> return self._inference </pre></div> <div class="docstring">Dynamically create and cache the Inference instance. </div> </div> <div id="PineconeAsyncio.create_index" class="classattr"> <input id="PineconeAsyncio.create_index-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def create_index( self, name: str, spec: Union[Dict, pinecone.models.serverless_spec.ServerlessSpec, pinecone.models.pod_spec.PodSpec], dimension: Optional[int] = None, metric: Union[pinecone.enums.metric.Metric, str, NoneType] = <Metric.COSINE: 'cosine'>, timeout: Optional[int] = None, deletion_protection: Union[pinecone.enums.deletion_protection.DeletionProtection, str, NoneType] = <DeletionProtection.DISABLED: 'disabled'>, vector_type: Union[pinecone.enums.vector_type.VectorType, str, NoneType] = <VectorType.DENSE: 'dense'>, tags: Optional[Dict[str, str]] = None) -> pinecone.models.index_model.IndexModel: <label class="view-source-button" for="PineconeAsyncio.create_index-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.create_index"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.create_index-167">167</a> async def create_index( <a href="#PineconeAsyncio.create_index-168">168</a> self, <a href="#PineconeAsyncio.create_index-169">169</a> name: str, <a href="#PineconeAsyncio.create_index-170">170</a> spec: Union[Dict, ServerlessSpec, PodSpec], <a href="#PineconeAsyncio.create_index-171">171</a> dimension: Optional[int] = None, <a href="#PineconeAsyncio.create_index-172">172</a> metric: Optional[Union[Metric, str]] = Metric.COSINE, <a href="#PineconeAsyncio.create_index-173">173</a> timeout: Optional[int] = None, <a href="#PineconeAsyncio.create_index-174">174</a> deletion_protection: Optional[Union[DeletionProtection, str]] = DeletionProtection.DISABLED, <a href="#PineconeAsyncio.create_index-175">175</a> vector_type: Optional[Union[VectorType, str]] = VectorType.DENSE, <a href="#PineconeAsyncio.create_index-176">176</a> tags: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio.create_index-177">177</a> ) -> IndexModel: <a href="#PineconeAsyncio.create_index-178">178</a> req = PineconeDBControlRequestFactory.create_index_request( <a href="#PineconeAsyncio.create_index-179">179</a> name=name, <a href="#PineconeAsyncio.create_index-180">180</a> spec=spec, <a href="#PineconeAsyncio.create_index-181">181</a> dimension=dimension, <a href="#PineconeAsyncio.create_index-182">182</a> metric=metric, <a href="#PineconeAsyncio.create_index-183">183</a> deletion_protection=deletion_protection, <a href="#PineconeAsyncio.create_index-184">184</a> vector_type=vector_type, <a href="#PineconeAsyncio.create_index-185">185</a> tags=tags, <a href="#PineconeAsyncio.create_index-186">186</a> ) <a href="#PineconeAsyncio.create_index-187">187</a> resp = await self.index_api.create_index(create_index_request=req) <a href="#PineconeAsyncio.create_index-188">188</a> <a href="#PineconeAsyncio.create_index-189">189</a> if timeout == -1: <a href="#PineconeAsyncio.create_index-190">190</a> return IndexModel(resp) <a href="#PineconeAsyncio.create_index-191">191</a> return await self.__poll_describe_index_until_ready(name, timeout) </pre></div> <div class="docstring">Creates a Pinecone index. <h6 id="parameters">Parameters</h6> <ul> <li>name: The name of the index to create. Must be unique within your project and cannot be changed once created. Allowed characters are lowercase letters, numbers, and hyphens and the name may not begin or end with hyphens. Maximum length is 45 characters.</li> <li>metric: Type of similarity metric used in the vector index when querying, one of <code>{"cosine", "dotproduct", "euclidean"}</code>.</li> <li>spec: A dictionary containing configurations describing how the index should be deployed. For serverless indexes, specify region and cloud. For pod indexes, specify replicas, shards, pods, pod_type, metadata_config, and source_collection. Alternatively, use the <code>ServerlessSpec</code> or <code>PodSpec</code> objects to specify these configurations.</li> <li>dimension: If you are creating an index with <code>vector_type="dense"</code> (which is the default), you need to specify <code>dimension</code> to indicate the size of your vectors. This should match the dimension of the embeddings you will be inserting. For example, if you are using OpenAI's CLIP model, you should use <code>dimension=1536</code>. Dimension is a required field when creating an index with <code>vector_type="dense"</code> and should not be passed when <code>vector_type="sparse"</code>.</li> <li>timeout: Specify the number of seconds to wait until index gets ready. If None, wait indefinitely; if >=0, time out after this many seconds; if -1, return immediately and do not wait.</li> <li>deletion_protection: If enabled, the index cannot be deleted. If disabled, the index can be deleted.</li> <li>vector_type: The type of vectors to be stored in the index. One of <code>{"dense", "sparse"}</code>.</li> <li>tags: Tags are key-value pairs you can attach to indexes to better understand, organize, and identify your resources. Some example use cases include tagging indexes with the name of the model that generated the embeddings, the date the index was created, or the purpose of the index.</li> </ul> <h6 id="returns">Returns</h6> <blockquote> A <code>IndexModel</code> instance containing a description of the index that was created. </blockquote> <h3 id="creating-a-serverless-index">Creating a serverless index</h3> <div class="pdoc-code codehilite"> <pre><code>import os import asyncio from pinecone import ( PineconeAsyncio, ServerlessSpec, CloudProvider, AwsRegion, Metric, DeletionProtection, VectorType ) async def main(): async with PineconeAsyncio(api_key=os.environ.get("PINECONE_API_KEY")) as pc: await pc.create_index( name="my_index", dimension=1536, metric=Metric.COSINE, spec=ServerlessSpec( cloud=CloudProvider.AWS, region=AwsRegion.US_WEST_2 ), deletion_protection=DeletionProtection.DISABLED, vector_type=VectorType.DENSE, tags={ "model": "clip", "app": "image-search", "env": "testing" } ) asyncio.run(main()) </code></pre> </div> <h3 id="creating-a-pod-index">Creating a pod index</h3> <div class="pdoc-code codehilite"> <pre><code>import os import asyncio from pinecone import ( Pinecone, PodSpec, PodIndexEnvironment, PodType, Metric, DeletionProtection, VectorType ) async def main(): async with Pinecone(api_key=os.environ.get("PINECONE_API_KEY")) as pc: await pc.create_index( name="my_index", dimension=1536, metric=Metric.COSINE, spec=PodSpec( environment=PodIndexEnvironment.US_EAST4_GCP, pod_type=PodType.P1_X1 ), deletion_protection=DeletionProtection.DISABLED, tags={ "model": "clip", "app": "image-search", "env": "testing" } ) asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.create_index_for_model" class="classattr"> <input id="PineconeAsyncio.create_index_for_model-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def create_index_for_model( self, name: str, cloud: Union[pinecone.enums.clouds.CloudProvider, str], region: Union[pinecone.enums.clouds.AwsRegion, pinecone.enums.clouds.GcpRegion, pinecone.enums.clouds.AzureRegion, str], embed: Union[pinecone.models.index_embed.IndexEmbed, <a href="types/create_index_for_model_embed.html#CreateIndexForModelEmbedTypedDict">pinecone.control.types.create_index_for_model_embed.CreateIndexForModelEmbedTypedDict</a>], tags: Optional[Dict[str, str]] = None, deletion_protection: Union[pinecone.enums.deletion_protection.DeletionProtection, str, NoneType] = <DeletionProtection.DISABLED: 'disabled'>, timeout: Optional[int] = None) -> pinecone.models.index_model.IndexModel: <label class="view-source-button" for="PineconeAsyncio.create_index_for_model-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.create_index_for_model"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.create_index_for_model-193">193</a> async def create_index_for_model( <a href="#PineconeAsyncio.create_index_for_model-194">194</a> self, <a href="#PineconeAsyncio.create_index_for_model-195">195</a> name: str, <a href="#PineconeAsyncio.create_index_for_model-196">196</a> cloud: Union[CloudProvider, str], <a href="#PineconeAsyncio.create_index_for_model-197">197</a> region: Union[AwsRegion, GcpRegion, AzureRegion, str], <a href="#PineconeAsyncio.create_index_for_model-198">198</a> embed: Union[IndexEmbed, CreateIndexForModelEmbedTypedDict], <a href="#PineconeAsyncio.create_index_for_model-199">199</a> tags: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio.create_index_for_model-200">200</a> deletion_protection: Optional[Union[DeletionProtection, str]] = DeletionProtection.DISABLED, <a href="#PineconeAsyncio.create_index_for_model-201">201</a> timeout: Optional[int] = None, <a href="#PineconeAsyncio.create_index_for_model-202">202</a> ) -> IndexModel: <a href="#PineconeAsyncio.create_index_for_model-203">203</a> req = PineconeDBControlRequestFactory.create_index_for_model_request( <a href="#PineconeAsyncio.create_index_for_model-204">204</a> name=name, <a href="#PineconeAsyncio.create_index_for_model-205">205</a> cloud=cloud, <a href="#PineconeAsyncio.create_index_for_model-206">206</a> region=region, <a href="#PineconeAsyncio.create_index_for_model-207">207</a> embed=embed, <a href="#PineconeAsyncio.create_index_for_model-208">208</a> tags=tags, <a href="#PineconeAsyncio.create_index_for_model-209">209</a> deletion_protection=deletion_protection, <a href="#PineconeAsyncio.create_index_for_model-210">210</a> ) <a href="#PineconeAsyncio.create_index_for_model-211">211</a> resp = await self.index_api.create_index_for_model(req) <a href="#PineconeAsyncio.create_index_for_model-212">212</a> <a href="#PineconeAsyncio.create_index_for_model-213">213</a> if timeout == -1: <a href="#PineconeAsyncio.create_index_for_model-214">214</a> return IndexModel(resp) <a href="#PineconeAsyncio.create_index_for_model-215">215</a> return await self.__poll_describe_index_until_ready(name, timeout) </pre></div> <div class="docstring"><h6 id="parameters">Parameters</h6> <ul> <li>name: The name of the index to create. Must be unique within your project and cannot be changed once created. Allowed characters are lowercase letters, numbers, and hyphens and the name may not begin or end with hyphens. Maximum length is 45 characters.</li> <li>cloud: The cloud provider to use for the index. One of <code>{"aws", "gcp", "azure"}</code>.</li> <li>region: The region to use for the index. Enum objects <code>AwsRegion</code>, <code>GcpRegion</code>, and <code>AzureRegion</code> are also available to help you quickly set these parameters, but may not be up to date as new regions become available.</li> <li>embed: The embedding configuration for the index. This param accepts a dictionary or an instance of the <code>IndexEmbed</code> object.</li> <li>tags: Tags are key-value pairs you can attach to indexes to better understand, organize, and identify your resources. Some example use cases include tagging indexes with the name of the model that generated the embeddings, the date the index was created, or the purpose of the index.</li> <li>deletion_protection: If enabled, the index cannot be deleted. If disabled, the index can be deleted. This setting can be changed with <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code>.</li> <li>timeout: Specify the number of seconds to wait until index is ready to receive data. If None, wait indefinitely; if >=0, time out after this many seconds; if -1, return immediately and do not wait.</li> </ul> <h6 id="returns">Returns</h6> <blockquote> A description of the index that was created. </blockquote> This method is used to create a Serverless index that is configured for use with Pinecone's integrated inference models. The resulting index can be described, listed, configured, and deleted like any other Pinecone index with the <code><a href="#PineconeAsyncio.describe_index">describe_index</a></code>, <code><a href="#PineconeAsyncio.list_indexes">list_indexes</a></code>, <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code>, and <code><a href="#PineconeAsyncio.delete_index">delete_index</a></code> methods. After the model is created, you can upsert records into the index with the <code>upsert_records</code> method, and search your records with the <code>search</code> method. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import ( PineconeAsyncio, IndexEmbed, CloudProvider, AwsRegion, EmbedModel, Metric, ) async def main(): async with PineconeAsyncio() as pc: if not await pc.has_index("book-search"): desc = await pc.create_index_for_model( name="book-search", cloud=CloudProvider.AWS, region=AwsRegion.US_EAST_1, embed=IndexEmbed( model=EmbedModel.Multilingual_E5_Large, metric=Metric.COSINE, field_map={ "text": "description", }, ) ) asyncio.run(main()) </code></pre> </div> To see the available cloud regions, see this <a href="https://docs<a href="pinecone.html">pinecone.control.pinecone</a>.io/troubleshooting/available-cloud-regions">Pinecone documentation</a> page. See the <a href="https://docs<a href="pinecone.html">pinecone.control.pinecone</a>.io/models/overview">Model Gallery</a> to learn about available models. </div> </div> <div id="PineconeAsyncio.delete_index" class="classattr"> <input id="PineconeAsyncio.delete_index-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def delete_index(self, name: str, timeout: Optional[int] = None): <label class="view-source-button" for="PineconeAsyncio.delete_index-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.delete_index"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.delete_index-255">255</a> async def delete_index(self, name: str, timeout: Optional[int] = None): <a href="#PineconeAsyncio.delete_index-256">256</a> await self.index_api.delete_index(name) <a href="#PineconeAsyncio.delete_index-257">257</a> <a href="#PineconeAsyncio.delete_index-258">258</a> if timeout == -1: <a href="#PineconeAsyncio.delete_index-259">259</a> return <a href="#PineconeAsyncio.delete_index-260">260</a> <a href="#PineconeAsyncio.delete_index-261">261</a> if timeout is None: <a href="#PineconeAsyncio.delete_index-262">262</a> while await self.has_index(name): <a href="#PineconeAsyncio.delete_index-263">263</a> await asyncio.sleep(5) <a href="#PineconeAsyncio.delete_index-264">264</a> else: <a href="#PineconeAsyncio.delete_index-265">265</a> while await self.has_index(name) and timeout >= 0: <a href="#PineconeAsyncio.delete_index-266">266</a> await asyncio.sleep(5) <a href="#PineconeAsyncio.delete_index-267">267</a> timeout -= 5 <a href="#PineconeAsyncio.delete_index-268">268</a> if timeout and timeout < 0: <a href="#PineconeAsyncio.delete_index-269">269</a> raise ( <a href="#PineconeAsyncio.delete_index-270">270</a> TimeoutError( <a href="#PineconeAsyncio.delete_index-271">271</a> "Please call the list_indexes API ({}) to confirm if index is deleted".format( <a href="#PineconeAsyncio.delete_index-272">272</a> "https://www.pinecone.io/docs/api/operation/list_indexes/" <a href="#PineconeAsyncio.delete_index-273">273</a> ) <a href="#PineconeAsyncio.delete_index-274">274</a> ) <a href="#PineconeAsyncio.delete_index-275">275</a> ) </pre></div> <div class="docstring"><h6 id="parameters">Parameters</h6> <ul> <li>name: the name of the index.</li> <li>timeout: Number of seconds to poll status checking whether the index has been deleted. If None, wait indefinitely; if >=0, time out after this many seconds; if -1, return immediately and do not wait.</li> </ul> Deletes a Pinecone index. Deleting an index is an irreversible operation. All data in the index will be lost. When you use this command, a request is sent to the Pinecone control plane to delete the index, but the termination is not synchronous because resources take a few moments to be released. By default the <code><a href="#PineconeAsyncio.delete_index">delete_index</a></code> method will block until polling of the <code><a href="#PineconeAsyncio.describe_index">describe_index</a></code> method shows that the delete operation has completed. If you prefer to return immediately and not wait for the index to be deleted, you can pass <code>timeout=-1</code> to the method. After the delete request is submitted, polling <code><a href="#PineconeAsyncio.describe_index">describe_index</a></code> will show that the index transitions into a <code>Terminating</code> state before eventually resulting in a 404 after it has been removed. This operation can fail if the index is configured with <code>deletion_protection="enabled"</code>. In this case, you will need to call <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code> to disable deletion protection before you can delete the index. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): pc = PineconeAsyncio() index_name = "my_index" desc = await pc.describe_index(name=index_name) if desc.deletion_protection == "enabled": # If for some reason deletion protection is enabled, you will need to disable it first # before you can delete the index. But use caution as this operation is not reversible # and if somebody enabled deletion protection, they probably had a good reason. await pc.configure_index(name=index_name, deletion_protection="disabled") await pc.delete_index(name=index_name) await pc.close() asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.list_indexes" class="classattr"> <input id="PineconeAsyncio.list_indexes-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def list_indexes(self) -> pinecone.models.index_list.IndexList: <label class="view-source-button" for="PineconeAsyncio.list_indexes-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.list_indexes"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.list_indexes-277">277</a> async def list_indexes(self) -> IndexList: <a href="#PineconeAsyncio.list_indexes-278">278</a> response = await self.index_api.list_indexes() <a href="#PineconeAsyncio.list_indexes-279">279</a> return IndexList(response) </pre></div> <div class="docstring"><h6 id="returns">Returns</h6> <blockquote> Returns an <code>IndexList</code> object, which is iterable and contains a list of <code>IndexModel</code> objects. The <code>IndexList</code> also has a convenience method <code>names()</code> which returns a list of index names for situations where you just want to iterate over all index names. </blockquote> Lists all indexes in your project. The results include a description of all indexes in your project, including the index name, dimension, metric, status, and spec. If you simply want to check whether an index exists, see the <code><a href="#PineconeAsyncio.has_index">has_index()</a></code> convenience method. You can use the <code><a href="#PineconeAsyncio.list_indexes">list_indexes()</a></code> method to iterate over descriptions of every index in your project. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): pc = PineconeAsyncio() available_indexes = await pc.list_indexes() for index in available_indexes: print(index.name) print(index.dimension) print(index.metric) print(index.status) print(index.host) print(index.spec) await pc.close() asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.describe_index" class="classattr"> <input id="PineconeAsyncio.describe_index-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def describe_index(self, name: str) -> pinecone.models.index_model.IndexModel: <label class="view-source-button" for="PineconeAsyncio.describe_index-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.describe_index"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.describe_index-281">281</a> async def describe_index(self, name: str) -> IndexModel: <a href="#PineconeAsyncio.describe_index-282">282</a> description = await self.index_api.describe_index(name) <a href="#PineconeAsyncio.describe_index-283">283</a> return IndexModel(description) </pre></div> <div class="docstring"><h6 id="parameters">Parameters</h6> <ul> <li>name: the name of the index to describe.</li> </ul> <h6 id="returns">Returns</h6> <blockquote> Returns an <code>IndexModel</code> object which gives access to properties such as the index name, dimension, metric, host url, status, and spec. </blockquote> Describes a Pinecone index. <h3 id="getting-your-index-host-url">Getting your index host url</h3> In a real production situation, you probably want to store the host url in an environment variable so you don't have to call describe_index and re-fetch it every time you want to use the index. But this example shows how to get the value from the API using describe_index. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import Pinecone, PineconeAsyncio, Index async def main(): pc = PineconeAsyncio() index_name="my_index" description = await pc.describe_index(name=index_name) print(description) # { # "name": "my_index", # "metric": "cosine", # "host": "my_index-dojoi3u.svc.aped-4627-b74a.pinecone.io", # "spec": { # "serverless": { # "cloud": "aws", # "region": "us-east-1" # } # }, # "status": { # "ready": true, # "state": "Ready" # }, # "vector_type": "dense", # "dimension": 1024, # "deletion_protection": "enabled", # "tags": { # "environment": "production" # } # } print(f"Your index is hosted at {description.host}") await pc.close() async with Pinecone().IndexAsyncio(host=description.host) as idx: await idx.upsert(vectors=[...]) asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.has_index" class="classattr"> <input id="PineconeAsyncio.has_index-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def has_index(self, name: str) -> bool: <label class="view-source-button" for="PineconeAsyncio.has_index-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.has_index"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.has_index-285">285</a> async def has_index(self, name: str) -> bool: <a href="#PineconeAsyncio.has_index-286">286</a> available_indexes = await self.list_indexes() <a href="#PineconeAsyncio.has_index-287">287</a> if name in available_indexes.names(): <a href="#PineconeAsyncio.has_index-288">288</a> return True <a href="#PineconeAsyncio.has_index-289">289</a> else: <a href="#PineconeAsyncio.has_index-290">290</a> return False </pre></div> <div class="docstring"><h6 id="parameters">Parameters</h6> <ul> <li>name: The name of the index to check for existence.</li> </ul> <h6 id="returns">Returns</h6> <blockquote> Returns <code>True</code> if the index exists, <code>False</code> otherwise. </blockquote> Checks if a Pinecone index exists. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio, ServerlessSpec async def main(): async with PineconeAsyncio() as pc: index_name = "my_index" if not await pc.has_index(index_name): print("Index does not exist, creating...") pc.create_index( name=index_name, dimension=768, metric="cosine", spec=ServerlessSpec(cloud="aws", region="us-west-2") ) asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.configure_index" class="classattr"> <input id="PineconeAsyncio.configure_index-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def configure_index( self, name: str, replicas: Optional[int] = None, pod_type: Union[pinecone.enums.pod_type.PodType, str, NoneType] = None, deletion_protection: Union[pinecone.enums.deletion_protection.DeletionProtection, str, NoneType] = None, tags: Optional[Dict[str, str]] = None): <label class="view-source-button" for="PineconeAsyncio.configure_index-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.configure_index"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.configure_index-292">292</a> async def configure_index( <a href="#PineconeAsyncio.configure_index-293">293</a> self, <a href="#PineconeAsyncio.configure_index-294">294</a> name: str, <a href="#PineconeAsyncio.configure_index-295">295</a> replicas: Optional[int] = None, <a href="#PineconeAsyncio.configure_index-296">296</a> pod_type: Optional[Union[PodType, str]] = None, <a href="#PineconeAsyncio.configure_index-297">297</a> deletion_protection: Optional[Union[DeletionProtection, str]] = None, <a href="#PineconeAsyncio.configure_index-298">298</a> tags: Optional[Dict[str, str]] = None, <a href="#PineconeAsyncio.configure_index-299">299</a> ): <a href="#PineconeAsyncio.configure_index-300">300</a> description = await self.describe_index(name=name) <a href="#PineconeAsyncio.configure_index-301">301</a> <a href="#PineconeAsyncio.configure_index-302">302</a> req = PineconeDBControlRequestFactory.configure_index_request( <a href="#PineconeAsyncio.configure_index-303">303</a> description=description, <a href="#PineconeAsyncio.configure_index-304">304</a> replicas=replicas, <a href="#PineconeAsyncio.configure_index-305">305</a> pod_type=pod_type, <a href="#PineconeAsyncio.configure_index-306">306</a> deletion_protection=deletion_protection, <a href="#PineconeAsyncio.configure_index-307">307</a> tags=tags, <a href="#PineconeAsyncio.configure_index-308">308</a> ) <a href="#PineconeAsyncio.configure_index-309">309</a> await self.index_api.configure_index(name, configure_index_request=req) </pre></div> <div class="docstring"><h6 id="parameters">Parameters</h6> <ul> <li>name: the name of the Index</li> <li>replicas: the desired number of replicas, lowest value is 0.</li> <li>pod_type: the new pod_type for the index. To learn more about the available pod types, please see <a href="https://docs<a href="pinecone.html">pinecone.control.pinecone</a>.io/docs/indexes">Understanding Indexes</a></li> <li>deletion_protection: If set to 'enabled', the index cannot be deleted. If 'disabled', the index can be deleted.</li> <li>tags: A dictionary of tags to apply to the index. Tags are key-value pairs that can be used to organize and manage indexes. To remove a tag, set the value to "". Tags passed to configure_index will be merged with existing tags and any with the value empty string will be removed.</li> </ul> This method is used to modify an index's configuration. It can be used to: <ul> <li>Scale a pod-based index horizontally using <code>replicas</code></li> <li>Scale a pod-based index vertically using <code>pod_type</code></li> <li>Enable or disable deletion protection using <code>deletion_protection</code></li> <li>Add, change, or remove tags using <code>tags</code></li> </ul> <h2 id="scaling-pod-based-indexes">Scaling pod-based indexes</h2> To scale your pod-based index, you pass a <code>replicas</code> and/or <code>pod_type</code> param to the <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code> method. <code>pod_type</code> may be a string or a value from the <code>PodType</code> enum. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio, PodType async def main(): async with PineconeAsyncio() as pc: await pc.configure_index( name="my_index", replicas=2, pod_type=PodType.P1_X2 ) asyncio.run(main()) </code></pre> </div> After providing these new configurations, you must call <code><a href="#PineconeAsyncio.describe_index">describe_index</a></code> to see the status of the index as the changes are applied. <h2 id="enabling-or-disabling-deletion-protection">Enabling or disabling deletion protection</h2> To enable or disable deletion protection, pass the <code>deletion_protection</code> parameter to the <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code> method. When deletion protection is enabled, the index cannot be deleted with the <code><a href="#PineconeAsyncio.delete_index">delete_index</a></code> method. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio, DeletionProtection async def main(): async with PineconeAsyncio() as pc: # Enable deletion protection await pc.configure_index( name="my_index", deletion_protection=DeletionProtection.ENABLED ) # Call describe_index to see the change was applied. desc = await pc.describe_index("my_index") assert desc.deletion_protection == "enabled" # Disable deletion protection await pc.configure_index( name="my_index", deletion_protection=DeletionProtection.DISABLED ) asyncio.run(main()) </code></pre> </div> <h2 id="adding-changing-or-removing-tags">Adding, changing, or removing tags</h2> To add, change, or remove tags, pass the <code>tags</code> parameter to the <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code> method. When tags are passed using <code><a href="#PineconeAsyncio.configure_index">configure_index</a></code>, they are merged with any existing tags already on the index. To remove a tag, set the value of the key to an empty string. <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: # Add a tag await pc.configure_index(name="my_index", tags={"environment": "staging"}) # Change a tag await pc.configure_index(name="my_index", tags={"environment": "production"}) # Remove a tag await pc.configure_index(name="my_index", tags={"environment": ""}) # Call describe_index to view the tags are changed await pc.describe_index("my_index") print(desc.tags) asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.create_collection" class="classattr"> <input id="PineconeAsyncio.create_collection-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def create_collection(self, name: str, source: str): <label class="view-source-button" for="PineconeAsyncio.create_collection-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.create_collection"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.create_collection-311">311</a> async def create_collection(self, name: str, source: str): <a href="#PineconeAsyncio.create_collection-312">312</a> req = PineconeDBControlRequestFactory.create_collection_request(name=name, source=source) <a href="#PineconeAsyncio.create_collection-313">313</a> await self.index_api.create_collection(create_collection_request=req) </pre></div> <div class="docstring">Create a collection from a pod-based index <h6 id="parameters">Parameters</h6> <ul> <li>name: Name of the collection</li> <li>source: Name of the source index</li> </ul> </div> </div> <div id="PineconeAsyncio.list_collections" class="classattr"> <input id="PineconeAsyncio.list_collections-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def list_collections(self) -> pinecone.models.collection_list.CollectionList: <label class="view-source-button" for="PineconeAsyncio.list_collections-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.list_collections"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.list_collections-315">315</a> async def list_collections(self) -> CollectionList: <a href="#PineconeAsyncio.list_collections-316">316</a> response = await self.index_api.list_collections() <a href="#PineconeAsyncio.list_collections-317">317</a> return CollectionList(response) </pre></div> <div class="docstring">List all collections <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): pc = PineconeAsyncio() collections = await pc.list_collections() for collection in collections: print(collection.name) print(collection.source) # You can also iterate specifically over # a list of collection names by calling # the .names() helper. collection_name = "my_collection" collections = await pc.list_collections() if collection_name in collections.names(): print('Collection exists') await pc.close() asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.delete_collection" class="classattr"> <input id="PineconeAsyncio.delete_collection-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def delete_collection(self, name: str): <label class="view-source-button" for="PineconeAsyncio.delete_collection-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.delete_collection"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.delete_collection-319">319</a> async def delete_collection(self, name: str): <a href="#PineconeAsyncio.delete_collection-320">320</a> await self.index_api.delete_collection(name) </pre></div> <div class="docstring">Describes a collection. <h6 id="parameters">Parameters</h6> <ul> <li>The name of the collection</li> </ul> <h6 id="returns">Returns</h6> <blockquote> Description of the collection </blockquote> <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: description = await pc.describe_collection("my_collection") print(description.name) print(description.source) print(description.status) print(description.size) asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.describe_collection" class="classattr"> <input id="PineconeAsyncio.describe_collection-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> async def describe_collection(self, name: str): <label class="view-source-button" for="PineconeAsyncio.describe_collection-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.describe_collection"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.describe_collection-322">322</a> async def describe_collection(self, name: str): <a href="#PineconeAsyncio.describe_collection-323">323</a> return await self.index_api.describe_collection(name).to_dict() </pre></div> <div class="docstring">Describes a collection. <h6 id="parameters">Parameters</h6> <ul> <li>The name of the collection</li> </ul> <h6 id="returns">Returns</h6> <blockquote> Description of the collection </blockquote> <div class="pdoc-code codehilite"> <pre><code>import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio() as pc: description = await pc.describe_collection("my_collection") print(description.name) print(description.source) print(description.status) print(description.size) asyncio.run(main()) </code></pre> </div> </div> </div> <div id="PineconeAsyncio.IndexAsyncio" class="classattr"> <input id="PineconeAsyncio.IndexAsyncio-view-source" class="view-source-toggle-state" type="checkbox" aria-hidden="true" tabindex="-1"> <div class="attr function"> def IndexAsyncio(self, host: str, **kwargs) -> pinecone.data.index_asyncio._IndexAsyncio: <label class="view-source-button" for="PineconeAsyncio.IndexAsyncio-view-source">View Source</label> </div> <a class="headerlink" href="#PineconeAsyncio.IndexAsyncio"></a> <div class="pdoc-code codehilite"><pre><a href="#PineconeAsyncio.IndexAsyncio-325">325</a> def IndexAsyncio(self, host: str, **kwargs) -> _IndexAsyncio: <a href="#PineconeAsyncio.IndexAsyncio-326">326</a> api_key = self.config.api_key <a href="#PineconeAsyncio.IndexAsyncio-327">327</a> openapi_config = self.openapi_config <a href="#PineconeAsyncio.IndexAsyncio-328">328</a> <a href="#PineconeAsyncio.IndexAsyncio-329">329</a> if host is None or host == "": <a href="#PineconeAsyncio.IndexAsyncio-330">330</a> raise ValueError("A host must be specified") <a href="#PineconeAsyncio.IndexAsyncio-331">331</a> <a href="#PineconeAsyncio.IndexAsyncio-332">332</a> check_realistic_host(host) <a href="#PineconeAsyncio.IndexAsyncio-333">333</a> index_host = normalize_host(host) <a href="#PineconeAsyncio.IndexAsyncio-334">334</a> <a href="#PineconeAsyncio.IndexAsyncio-335">335</a> return _IndexAsyncio( <a href="#PineconeAsyncio.IndexAsyncio-336">336</a> host=index_host, <a href="#PineconeAsyncio.IndexAsyncio-337">337</a> api_key=api_key, <a href="#PineconeAsyncio.IndexAsyncio-338">338</a> openapi_config=openapi_config, <a href="#PineconeAsyncio.IndexAsyncio-339">339</a> source_tag=self.config.source_tag, <a href="#PineconeAsyncio.IndexAsyncio-340">340</a> **kwargs, <a href="#PineconeAsyncio.IndexAsyncio-341">341</a> ) </pre></div> <div class="docstring">Build an asyncio-compatible client for index data operations. <h6 id="parameters">Parameters</h6> <ul> <li>host: The host url of the index.</li> </ul> <div class="pdoc-code codehilite"> <pre><code>import os import asyncio from pinecone import PineconeAsyncio api_key = os.environ.get("PINECONE_API_KEY") index_host = os.environ.get("PINECONE_INDEX_HOST") async def main(): async with Pinecone(api_key=api_key) as pc: async with pc.Index(host=index_host) as idx: # Now you're ready to perform data operations await index.query(vector=[...], top_k=10) asyncio.run(main()) </code></pre> </div> To find your host url, you can use the <code><a href="#PineconeAsyncio.describe_index">describe_index</a></code>. Or, alternatively, the host is displayed in the Pinecone web console. <div class="pdoc-code codehilite"> <pre><code>import os import asyncio from pinecone import PineconeAsyncio async def main(): async with PineconeAsyncio( api_key=os.environ.get("PINECONE_API_KEY") ) as pc: host = await pc.describe_index('index-name').host asyncio.run(main()) </code></pre> </div> <h2 id="alternative-setup">Alternative setup</h2> Like instances of the <code><a href="#PineconeAsyncio">PineconeAsyncio</a></code> class, instances of <code><a href="#PineconeAsyncio.IndexAsyncio">IndexAsyncio</a></code> have async context that needs to be cleaned up when you are done with it in order to avoid error messages about unclosed session from aiohttp. Nesting these in code is a bit cumbersome, so if you are only planning to do data operations you may prefer to setup the <code><a href="#PineconeAsyncio.IndexAsyncio">IndexAsyncio</a></code> object via the <code>Pinecone</code> class which will avoid creating an outer async context. <div class="pdoc-code codehilite"> <pre><code>import os import asyncio from pinecone import Pinecone api_key = os.environ.get("PINECONE_API_KEY") async def main(): pc = Pinecone(api_key=api_key) # sync client, so no async context to worry about async with pc.AsyncioIndex(host='your_index_host') as idx: # Now you're ready to perform data operations await idx.query(vector=[...], top_k=10) </code></pre> </div> </div> </div> </section> </main> <script> function escapeHTML(html) { return document.createElement('div').appendChild(document.createTextNode(html)).parentNode.innerHTML; } const originalContent = document.querySelector("main.pdoc"); let currentContent = originalContent; function setContent(innerHTML) { let elem; if (innerHTML) { elem = document.createElement("main"); elem.classList.add("pdoc"); elem.innerHTML = innerHTML; } else { elem = originalContent; } if (currentContent !== elem) { currentContent.replaceWith(elem); currentContent = elem; } } function getSearchTerm() { return (new URL(window.location)).searchParams.get("search"); } const searchBox = document.querySelector(".pdoc input[type=search]"); searchBox.addEventListener("input", function () { let url = new URL(window.location); if (searchBox.value.trim()) { url.hash = ""; url.searchParams.set("search", searchBox.value); } else { url.searchParams.delete("search"); } history.replaceState("", "", url.toString()); onInput(); }); window.addEventListener("popstate", onInput); let search, searchErr; async function initialize() { try { search = await new Promise((resolve, reject) => { const script = document.createElement("script"); script.type = "text/javascript"; script.async = true; script.onload = () => resolve(window.pdocSearch); script.onerror = (e) => reject(e); script.src = "../../search.js"; document.getElementsByTagName("head")[0].appendChild(script); }); } catch (e) { console.error("Cannot fetch pdoc search index"); searchErr = "Cannot fetch search index."; } onInput(); document.querySelector("nav.pdoc").addEventListener("click", e => { if (e.target.hash) { searchBox.value = ""; searchBox.dispatchEvent(new Event("input")); } }); } function onInput() { setContent((() => { const term = getSearchTerm(); if (!term) { return null } if (searchErr) { return `<h3>Error: ${searchErr}</h3>` } if (!search) { return "<h3>Searching...</h3>" } window.scrollTo({top: 0, left: 0, behavior: 'auto'}); const results = search(term); let html; if (results.length === 0) { html = `No search results for '${escapeHTML(term)}'.` } else { html = `<h4>${results.length} search result${results.length > 1 ? "s" : ""} for '${escapeHTML(term)}'.</h4>`; } for (let result of results.slice(0, 10)) { let doc = result.doc; let url = `../../${doc.modulename.replaceAll(".", "/")}.html`; if (doc.qualname) { url += `#${doc.qualname}`; } let heading; switch (result.doc.kind) { case "function": if (doc.fullname.endsWith(".__init__")) { heading = `${doc.fullname.replace(/\.__init__$/, "")}${doc.signature}`; } else { heading = `${doc.funcdef} ${doc.fullname}${doc.signature}`; } break; case "class": heading = `class ${doc.fullname}`; if (doc.bases) heading += `(${doc.bases})`; heading += `:`; break; case "variable": heading = `${doc.fullname}`; if (doc.annotation) heading += `${doc.annotation}`; if (doc.default_value) heading += ` = ${doc.default_value}`; break; default: heading = `${doc.fullname}`; break; } html += ` <section class="search-result"> <a href="${url}" class="attr ${doc.kind}">${heading}</a> <div class="docstring">${doc.doc}</div> </section> `; } return html; })()); } if (getSearchTerm()) { initialize(); searchBox.value = getSearchTerm(); onInput(); } else { searchBox.addEventListener("focus", initialize, {once: true}); } searchBox.addEventListener("keydown", e => { if (["ArrowDown", "ArrowUp", "Enter"].includes(e.key)) { let focused = currentContent.querySelector(".search-result.focused"); if (!focused) { currentContent.querySelector(".search-result").classList.add("focused"); } else if ( e.key === "ArrowDown" && focused.nextElementSibling && focused.nextElementSibling.classList.contains("search-result") ) { focused.classList.remove("focused"); focused.nextElementSibling.classList.add("focused"); focused.nextElementSibling.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "nearest" }); } else if ( e.key === "ArrowUp" && focused.previousElementSibling && focused.previousElementSibling.classList.contains("search-result") ) { focused.classList.remove("focused"); focused.previousElementSibling.classList.add("focused"); focused.previousElementSibling.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "nearest" }); } else if ( e.key === "Enter" ) { focused.querySelector("a").click(); } } }); </script></body> </html>