fix poetry issues

Author: rohanshah18

pinecone/repository_control/request_factory.py

@@ -4,17 +4,22 @@
 from pinecone.utils import parse_non_empty_args, convert_enum_to_string
 
 from pinecone.core.openapi.repository_control.model.create_repository_request import (
-    CreateRepositoryRequest,
+    CreateRepositoryRequest as OpenAPICreateRepositoryRequest,
+)
+from pinecone.core.openapi.repository_control.model.repository_spec import (
+    RepositorySpec as OpenAPIRepositorySpec,
 )
-from pinecone.core.openapi.repository_control.model.repository_spec import RepositorySpec
 from pinecone.core.openapi.repository_control.model.serverless_spec import (
-    ServerlessSpec as ServerlessSpecModel,
+    ServerlessSpec as OpenAPIServerlessSpec,
+)
+from pinecone.core.openapi.repository_control.model.document_schema import (
+    DocumentSchema as OpenAPIDocumentSchema,
 )
-from pinecone.core.openapi.repository_control.model.serverless_spec import ServerlessSpec
-from pinecone.core.openapi.repository_control.model.document_schema import DocumentSchema
 from pinecone.core.openapi.repository_control.model.document_schema_field_map import (
-    DocumentSchemaFieldMap,
+    DocumentSchemaFieldMap as OpenAPIDocumentSchemaFieldMap,
 )
+from pinecone.repository_control.models.serverless_spec import ServerlessSpec
+from pinecone.repository_control.models.document_schema import DocumentSchema
 
 
 logger = logging.getLogger(__name__)
@@ -29,20 +34,20 @@ class PineconeRepositoryControlRequestFactory:
     """
 
     @staticmethod
-    def __parse_repository_spec(spec: Union[Dict, ServerlessSpec]) -> RepositorySpec:
+    def __parse_repository_spec(spec: Union[Dict, ServerlessSpec]) -> OpenAPIRepositorySpec:
         if isinstance(spec, dict):
             if "serverless" in spec:
                 spec["serverless"]["cloud"] = convert_enum_to_string(spec["serverless"]["cloud"])
                 spec["serverless"]["region"] = convert_enum_to_string(spec["serverless"]["region"])
 
-                repository_spec = RepositorySpec(
-                    serverless=ServerlessSpecModel(**spec["serverless"])
+                repository_spec = OpenAPIRepositorySpec(
+                    serverless=OpenAPIServerlessSpec(**spec["serverless"])
                 )
             else:
                 raise ValueError("spec must contain a 'serverless' key")
         elif isinstance(spec, ServerlessSpec):
-            repository_spec = RepositorySpec(
-                serverless=ServerlessSpecModel(cloud=spec.cloud, region=spec.region)
+            repository_spec = OpenAPIRepositorySpec(
+                serverless=OpenAPIServerlessSpec(cloud=spec.cloud, region=spec.region)
             )
         else:
             raise TypeError("spec must be of type dict or ServerlessSpec")
@@ -53,9 +58,10 @@ def __parse_repository_spec(spec: Union[Dict, ServerlessSpec]) -> RepositorySpec
     def __parse_repository_schema(schema: Union[Dict, DocumentSchema]) -> DocumentSchema:
         if isinstance(schema, dict):
             if "fields" in schema:
-                repository_schema = DocumentSchema(
-                    fields=DocumentSchemaFieldMap(**schema["fields"])
+                openapi_schema = OpenAPIDocumentSchema(
+                    fields=OpenAPIDocumentSchemaFieldMap(**schema["fields"])
                 )
+                repository_schema = DocumentSchema(openapi_schema)
             else:
                 raise ValueError("schema must contain a 'fields' key")
         elif isinstance(schema, DocumentSchema):
@@ -68,10 +74,10 @@ def __parse_repository_schema(schema: Union[Dict, DocumentSchema]) -> DocumentSc
     @staticmethod
     def create_repository_request(
         name: str, spec: Union[Dict, ServerlessSpec], schema: Union[Dict, DocumentSchema]
-    ) -> CreateRepositoryRequest:
-        spec = PineconeRepositoryControlRequestFactory.__parse_repository_spec(spec)
-        schema = PineconeRepositoryControlRequestFactory.__parse_repository_schema(schema)
+    ) -> OpenAPICreateRepositoryRequest:
+        parsed_spec = PineconeRepositoryControlRequestFactory.__parse_repository_spec(spec)
+        parsed_schema = PineconeRepositoryControlRequestFactory.__parse_repository_schema(schema)
 
-        args = parse_non_empty_args([("name", name), ("spec", spec), ("schema", schema)])
+        args = parse_non_empty_args([("name", name), ("spec", parsed_spec), ("schema", parsed_schema)])
 
-        return CreateRepositoryRequest(**args)
+        return OpenAPICreateRepositoryRequest(**args)