add python 3 codegen

bin/python3-petstore.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/python3 -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l python3 -o samples/client/petstore/python3"
+
+java $JAVA_OPTS -jar $executable $ags

modules/swagger-codegen/src/main/java/com/wordnik/swagger/codegen/languages/Python3ClientCodegen.java

@@ -0,0 +1,189 @@
+package com.wordnik.swagger.codegen.languages;
+
+import com.wordnik.swagger.codegen.*;
+import com.wordnik.swagger.models.properties.*;
+
+import java.io.File;
+import java.util.*;
+
+public class Python3ClientCodegen extends DefaultCodegen implements CodegenConfig {
+  String module = "client";
+
+  public CodegenType getTag() {
+    return CodegenType.CLIENT;
+  }
+
+  public String getName() {
+    return "python3";
+  }
+
+  public String getHelp() {
+    return "Generates a Python3 client library.";
+  }
+
+  public Python3ClientCodegen() {
+    super();
+    outputFolder = "generated-code/python3";
+    modelTemplateFiles.put("model.mustache", ".py");
+    apiTemplateFiles.put("api.mustache", ".py");
+    templateDir = "python3";
+
+    apiPackage = module;
+    modelPackage = module + ".models";
+
+    languageSpecificPrimitives.clear();
+    languageSpecificPrimitives.add("int");
+    languageSpecificPrimitives.add("float");
+    //languageSpecificPrimitives.add("long");
+    languageSpecificPrimitives.add("list");
+    languageSpecificPrimitives.add("bool");
+    languageSpecificPrimitives.add("str");
+    languageSpecificPrimitives.add("datetime");
+
+    typeMapping.clear();
+    typeMapping.put("integer", "int");
+    typeMapping.put("float", "float");
+    typeMapping.put("long", "int");
+    typeMapping.put("double", "float");
+    typeMapping.put("array", "list");
+    typeMapping.put("map", "map");
+    typeMapping.put("boolean", "bool");
+    typeMapping.put("string", "str");
+    typeMapping.put("date", "datetime");
+
+    // from https://docs.python.org/release/2.5.4/ref/keywords.html
+    reservedWords = new HashSet<String> (
+      Arrays.asList(
+        "and", "del", "from", "not", "while", "as", "elif", "global", "or", "with",
+        "assert", "else", "if", "pass", "yield", "break", "except", "import",
+        "print", "class", "exec", "in", "raise", "continue", "finally", "is",
+        "return", "def", "for", "lambda", "try"));
+
+    //supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));
+    supportingFiles.add(new SupportingFile("swagger.mustache", module, "swagger.py"));
+    supportingFiles.add(new SupportingFile("__init__.mustache", module, "__init__.py"));
+  }
+
+  @Override
+  public String escapeReservedWord(String name) {
+    return "_" + name;
+  }
+
+  @Override
+  public String apiFileFolder() {
+    return outputFolder + "/" + apiPackage().replace('.', File.separatorChar);
+  }
+
+  public String modelFileFolder() {
+    return outputFolder + "/" + modelPackage().replace('.', File.separatorChar);
+  }
+
+  @Override
+  public String getTypeDeclaration(Property p) {
+    if(p instanceof ArrayProperty) {
+      ArrayProperty ap = (ArrayProperty) p;
+      Property inner = ap.getItems();
+      return getSwaggerType(p) + "[" + getTypeDeclaration(inner) + "]";
+    }
+    else if (p instanceof MapProperty) {
+      MapProperty mp = (MapProperty) p;
+      Property inner = mp.getAdditionalProperties();
+
+      return getSwaggerType(p) + "(String, " + getTypeDeclaration(inner) + ")";
+    }
+    return super.getTypeDeclaration(p);
+  }
+
+  @Override
+  public String getSwaggerType(Property p) {
+    String swaggerType = super.getSwaggerType(p);
+    String type = null;
+    if(typeMapping.containsKey(swaggerType)) {
+      type = typeMapping.get(swaggerType);
+      if(languageSpecificPrimitives.contains(type)) {
+        return type;
+      }
+    }
+    else
+      type = swaggerType;
+    return type;
+  }
+
+  public String toDefaultValue(Property p) {
+	// TODO: Support Python def value
+    return "null";
+  }
+
+  @Override
+  public String toVarName(String name) {
+    // replace - with _ e.g. created-at => created_at
+    name = name.replaceAll("-", "_");
+
+    // if it's all uppper case, convert to lower case
+    if (name.matches("^[A-Z_]*$"))
+      name = name.toLowerCase();
+
+    // camelize (lower first character) the variable name
+    // petId => pet_id
+    name = underscore(name);
+
+    // for reserved word or word starting with number, append _
+    if(reservedWords.contains(name) || name.matches("^\\d.*"))
+      name = escapeReservedWord(name);
+
+    return name;
+  }
+
+  @Override
+  public String toParamName(String name) {
+    // should be the same as variable name
+    return toVarName(name);
+  }
+
+  @Override
+  public String toModelName(String name) {
+    // model name cannot use reserved keyword, e.g. return
+    if(reservedWords.contains(name))
+      throw new RuntimeException(name + " (reserved word) cannot be used as a model name");
+
+    // camelize the model name
+    // phone_number => PhoneNumber
+    return camelize(name);
+  }
+
+  @Override
+  public String toModelFilename(String name) {
+    // model name cannot use reserved keyword, e.g. return
+    if(reservedWords.contains(name))
+      throw new RuntimeException(name + " (reserved word) cannot be used as a model name");
+
+    // underscore the model file name
+    // PhoneNumber.rb => phone_number.rb
+    return underscore(name);
+  }
+
+  @Override
+  public String toApiFilename(String name) {
+    // replace - with _ e.g. created-at => created_at
+    name = name.replaceAll("-", "_");
+
+    // e.g. PhoneNumberApi.rb => phone_number_api.rb
+    return underscore(name) + "_api";
+  }
+
+  @Override
+  public String toApiName(String name) {
+    if(name.length() == 0)
+      return "DefaultApi";
+    // e.g. phone_number_api => PhoneNumberApi
+    return camelize(name) + "Api";
+  }
+
+  @Override
+  public String toApiVarName(String name) {
+      if(name.length() == 0)
+          return "default_api";
+    return underscore(name) + "_api";
+  }
+
+}

modules/swagger-codegen/src/main/resources/META-INF/services/com.wordnik.swagger.codegen.CodegenConfig

@@ -7,6 +7,7 @@ com.wordnik.swagger.codegen.languages.NodeJSServerCodegen
 com.wordnik.swagger.codegen.languages.ObjcClientCodegen
 com.wordnik.swagger.codegen.languages.PhpClientCodegen
 com.wordnik.swagger.codegen.languages.PythonClientCodegen
+com.wordnik.swagger.codegen.languages.Python3ClientCodegen
 com.wordnik.swagger.codegen.languages.RubyClientCodegen
 com.wordnik.swagger.codegen.languages.ScalaClientCodegen
 com.wordnik.swagger.codegen.languages.ScalatraServerCodegen

samples/client/petstore/python3/client/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+"""Add all of the modules in the current directory to __all__"""
+import os
+
+__all__ = []
+
+for module in os.listdir(os.path.dirname(__file__)):
+    if module != '__init__.py' and module[-3:] == '.py':
+        __all__.append(module[:-3])

samples/client/petstore/python3/client/models/category.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+"""
+Copyright 2015 Reverb Technologies, Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+
+class Category:
+    """NOTE: This class is auto generated by the swagger code generator program.
+    Do not edit the class manually."""
+
+
+    def __init__(self):
+        self.swaggerTypes = {
+            
+            'id': 'int',
+            
+            
+            'name': 'str'
+            
+        }
+
+
+        
+        
+        self.id = None # int
+        
+        
+        self.name = None # str
+        

samples/client/petstore/python3/client/models/order.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+"""
+Copyright 2015 Reverb Technologies, Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+
+class Order:
+    """NOTE: This class is auto generated by the swagger code generator program.
+    Do not edit the class manually."""
+
+
+    def __init__(self):
+        self.swaggerTypes = {
+            
+            'id': 'int',
+            
+            
+            'pet_id': 'int',
+            
+            
+            'quantity': 'int',
+            
+            
+            'ship_date': 'DateTime',
+            
+            
+            'status': 'str',
+            
+            
+            'complete': 'bool'
+            
+        }
+
+
+        
+        
+        self.id = None # int
+        
+        
+        self.pet_id = None # int
+        
+        
+        self.quantity = None # int
+        
+        
+        self.ship_date = None # DateTime
+        
+        #Order Status
+        
+        self.status = None # str
+        
+        
+        self.complete = None # bool
+        

samples/client/petstore/python3/client/models/pet.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+"""
+Copyright 2015 Reverb Technologies, Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+
+class Pet:
+    """NOTE: This class is auto generated by the swagger code generator program.
+    Do not edit the class manually."""
+
+
+    def __init__(self):
+        self.swaggerTypes = {
+            
+            'id': 'int',
+            
+            
+            'category': 'Category',
+            
+            
+            'name': 'str',
+            
+            
+            'photo_urls': 'list[str]',
+            
+            
+            'tags': 'list[Tag]',
+            
+            
+            'status': 'str'
+            
+        }
+
+
+        
+        
+        self.id = None # int
+        
+        
+        self.category = None # Category
+        
+        
+        self.name = None # str
+        
+        
+        self.photo_urls = None # list[str]
+        
+        
+        self.tags = None # list[Tag]
+        
+        #pet status in the store
+        
+        self.status = None # str
+        

samples/client/petstore/python3/client/models/tag.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+"""
+Copyright 2015 Reverb Technologies, Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+
+class Tag:
+    """NOTE: This class is auto generated by the swagger code generator program.
+    Do not edit the class manually."""
+
+
+    def __init__(self):
+        self.swaggerTypes = {
+            
+            'id': 'int',
+            
+            
+            'name': 'str'
+            
+        }
+
+
+        
+        
+        self.id = None # int
+        
+        
+        self.name = None # str
+        

samples/client/petstore/python3/client/models/user.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+"""
+Copyright 2015 Reverb Technologies, Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+
+class User:
+    """NOTE: This class is auto generated by the swagger code generator program.
+    Do not edit the class manually."""
+
+
+    def __init__(self):
+        self.swaggerTypes = {
+            
+            'id': 'int',
+            
+            
+            'username': 'str',
+            
+            
+            'first_name': 'str',
+            
+            
+            'last_name': 'str',
+            
+            
+            'email': 'str',
+            
+            
+            'password': 'str',
+            
+            
+            'phone': 'str',
+            
+            
+            'user_status': 'int'
+            
+        }
+
+
+        
+        
+        self.id = None # int
+        
+        
+        self.username = None # str
+        
+        
+        self.first_name = None # str
+        
+        
+        self.last_name = None # str
+        
+        
+        self.email = None # str
+        
+        
+        self.password = None # str
+        
+        
+        self.phone = None # str
+        
+        #User Status
+        
+        self.user_status = None # int
+        

samples/client/petstore/python3/client/pet_api.py

@@ -0,0 +1,440 @@
+#!/usr/bin/env python
+"""
+PetApi.py
+Copyright 2015 Reverb Technologies, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually.
+"""
+import sys
+import os
+
+from .models import *
+
+
+class PetApi(object):
+
+    def __init__(self, apiClient):
+      self.apiClient = apiClient
+
+    
+    
+    def updatePet(self, **kwargs):
+        """Update an existing pet
+
+        Args:
+            
+            body, Pet: Pet object that needs to be added to the store (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method updatePet" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'PUT'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def addPet(self, **kwargs):
+        """Add a new pet to the store
+
+        Args:
+            
+            body, Pet: Pet object that needs to be added to the store (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method addPet" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def findPetsByStatus(self, **kwargs):
+        """Finds Pets by status
+
+        Args:
+            
+            status, list[str]: Status values that need to be considered for filter (required)
+            
+            
+        
+        Returns: list[Pet]
+        """
+
+        allParams = ['status']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method findPetsByStatus" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet/findByStatus'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+        if ('status' in params):
+            queryParams['status'] = self.apiClient.toPathValue(params['status'])
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'list[Pet]')
+        return responseObject
+        
+        
+        
+    
+    def findPetsByTags(self, **kwargs):
+        """Finds Pets by tags
+
+        Args:
+            
+            tags, list[str]: Tags to filter by (required)
+            
+            
+        
+        Returns: list[Pet]
+        """
+
+        allParams = ['tags']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method findPetsByTags" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet/findByTags'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+        if ('tags' in params):
+            queryParams['tags'] = self.apiClient.toPathValue(params['tags'])
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'list[Pet]')
+        return responseObject
+        
+        
+        
+    
+    def getPetById(self, **kwargs):
+        """Find pet by ID
+
+        Args:
+            
+            pet_id, int: ID of pet that needs to be fetched (required)
+            
+            
+        
+        Returns: Pet
+        """
+
+        allParams = ['pet_id']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method getPetById" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet/{petId}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('pet_id' in params):
+            replacement = str(self.apiClient.toPathValue(params['pet_id']))
+            resourcePath = resourcePath.replace('{' + 'petId' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'Pet')
+        return responseObject
+        
+        
+        
+    
+    def updatePetWithForm(self, **kwargs):
+        """Updates a pet in the store with form data
+
+        Args:
+            
+            pet_id, str: ID of pet that needs to be updated (required)
+            
+            
+            name, str: Updated name of the pet (required)
+            
+            
+            status, str: Updated status of the pet (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['pet_id', 'name', 'status']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method updatePetWithForm" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet/{petId}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('pet_id' in params):
+            replacement = str(self.apiClient.toPathValue(params['pet_id']))
+            resourcePath = resourcePath.replace('{' + 'petId' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def deletePet(self, **kwargs):
+        """Deletes a pet
+
+        Args:
+            
+            api_key, str:  (required)
+            
+            
+            pet_id, int: Pet id to delete (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['api_key', 'pet_id']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method deletePet" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet/{petId}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'DELETE'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+        if ('api_key' in params):
+            headerParams['api_key'] = params['api_key']
+        
+
+        
+        if ('pet_id' in params):
+            replacement = str(self.apiClient.toPathValue(params['pet_id']))
+            resourcePath = resourcePath.replace('{' + 'petId' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def uploadFile(self, **kwargs):
+        """uploads an image
+
+        Args:
+            
+            pet_id, int: ID of pet to update (required)
+            
+            
+            additional_metadata, str: Additional data to pass to server (required)
+            
+            
+            file, file: file to upload (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['pet_id', 'additional_metadata', 'file']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method uploadFile" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/pet/{petId}/uploadImage'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('pet_id' in params):
+            replacement = str(self.apiClient.toPathValue(params['pet_id']))
+            resourcePath = resourcePath.replace('{' + 'petId' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+
+

samples/client/petstore/python3/client/store_api.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+"""
+StoreApi.py
+Copyright 2015 Reverb Technologies, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually.
+"""
+import sys
+import os
+
+from .models import *
+
+
+class StoreApi(object):
+
+    def __init__(self, apiClient):
+      self.apiClient = apiClient
+
+    
+    
+    def getInventory(self, **kwargs):
+        """Returns pet inventories by status
+
+        Args:
+            
+        
+        Returns: map(String, int)
+        """
+
+        allParams = []
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method getInventory" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/store/inventory'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'map(String, int)')
+        return responseObject
+        
+        
+        
+    
+    def placeOrder(self, **kwargs):
+        """Place an order for a pet
+
+        Args:
+            
+            body, Order: order placed for purchasing the pet (required)
+            
+            
+        
+        Returns: Order
+        """
+
+        allParams = ['body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method placeOrder" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/store/order'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'Order')
+        return responseObject
+        
+        
+        
+    
+    def getOrderById(self, **kwargs):
+        """Find purchase order by ID
+
+        Args:
+            
+            order_id, str: ID of pet that needs to be fetched (required)
+            
+            
+        
+        Returns: Order
+        """
+
+        allParams = ['order_id']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method getOrderById" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/store/order/{orderId}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('order_id' in params):
+            replacement = str(self.apiClient.toPathValue(params['order_id']))
+            resourcePath = resourcePath.replace('{' + 'orderId' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'Order')
+        return responseObject
+        
+        
+        
+    
+    def deleteOrder(self, **kwargs):
+        """Delete purchase order by ID
+
+        Args:
+            
+            order_id, str: ID of the order that needs to be deleted (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['order_id']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method deleteOrder" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/store/order/{orderId}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'DELETE'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('order_id' in params):
+            replacement = str(self.apiClient.toPathValue(params['order_id']))
+            resourcePath = resourcePath.replace('{' + 'orderId' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+
+

samples/client/petstore/python3/client/swagger.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+"""Wordnik.com's Swagger generic API client. This client handles the client-
+server communication, and is invariant across implementations. Specifics of
+the methods and models for each application are generated from the Swagger
+templates."""
+
+import sys
+import os
+import re
+import urllib.request, urllib.error, urllib.parse
+import http.client
+import json
+import datetime
+
+from .models import *
+
+
+class ApiClient:
+    """Generic API client for Swagger client library builds"""
+
+    def __init__(self, apiKey=None, apiServer=None):
+        if apiKey == None:
+            raise Exception('You must pass an apiKey when instantiating the '
+                            'APIClient')
+        self.apiKey = apiKey
+        self.apiServer = apiServer
+        self.cookie = None
+
+    def callAPI(self, resourcePath, method, queryParams, postData,
+                headerParams=None):
+
+        url = self.apiServer + resourcePath
+        headers = {}
+        if headerParams:
+            for param, value in headerParams.items():
+                headers[param] = value
+
+        #headers['Content-type'] = 'application/json'
+        headers['api_key'] = self.apiKey
+
+        if self.cookie:
+            headers['Cookie'] = self.cookie
+
+        data = None
+
+        if queryParams:
+            # Need to remove None values, these should not be sent
+            sentQueryParams = {}
+            for param, value in queryParams.items():
+                if value != None:
+                    sentQueryParams[param] = value
+            url = url + '?' + urllib.parse.urlencode(sentQueryParams)
+
+        if method in ['GET']:
+
+            #Options to add statements later on and for compatibility
+            pass
+
+        elif method in ['PATCH', 'POST', 'PUT', 'DELETE']:
+
+            if postData:
+                headers['Content-type'] = 'application/json'
+                data = self.sanitizeForSerialization(postData)
+                data = json.dumps(data)
+
+        else:
+            raise Exception('Method ' + method + ' is not recognized.')
+
+        if data:
+            data = data.encode('utf-8')
+
+        requestParams = MethodRequest(method=method, url=url,
+                                       headers=headers, data=data)
+
+        # Make the request
+        request = urllib.request.urlopen(requestParams)
+        encoding = request.headers.get_content_charset()
+        if not encoding:
+            encoding = 'iso-8859-1'
+        response = request.read().decode(encoding)
+
+        try:
+            data = json.loads(response)
+        except ValueError:  # PUT requests don't return anything
+            data = None
+
+        return data
+
+    def toPathValue(self, obj):
+        """Convert a string or object to a path-friendly value
+        Args:
+            obj -- object or string value
+        Returns:
+            string -- quoted value
+        """
+        if type(obj) == list:
+            return urllib.parse.quote(','.join(obj))
+        else:
+            return urllib.parse.quote(str(obj))
+
+    def sanitizeForSerialization(self, obj):
+        """Dump an object into JSON for POSTing."""
+
+        if type(obj) == type(None):
+            return None
+        elif type(obj) in [str, int, float, bool]:
+            return obj
+        elif type(obj) == list:
+            return [self.sanitizeForSerialization(subObj) for subObj in obj]
+        elif type(obj) == datetime.datetime:
+            return obj.isoformat()
+        else:
+            if type(obj) == dict:
+                objDict = obj
+            else:
+                objDict = obj.__dict__
+            return {key: self.sanitizeForSerialization(val)
+                    for (key, val) in objDict.items()
+                    if key != 'swaggerTypes'}
+
+    def _iso8601Format(self, timesep, microsecond, offset, zulu):
+        """Format for parsing a datetime string with given properties.
+
+        Args:
+            timesep -- string separating time from date ('T' or 't')
+            microsecond -- microsecond portion of time ('.XXX')
+            offset -- time offset (+/-XX:XX) or None
+            zulu -- 'Z' or 'z' for UTC, or None for time offset (+/-XX:XX)
+
+        Returns:
+            str - format string for datetime.strptime"""
+
+        return '%Y-%m-%d{}%H:%M:%S{}{}'.format(
+            timesep,
+            '.%f' if microsecond else '',
+            zulu or ('%z' if offset else ''))
+
+    # http://xml2rfc.ietf.org/public/rfc/html/rfc3339.html#anchor14
+    _iso8601Regex = re.compile(
+        r'^\d\d\d\d-\d\d-\d\d([Tt])\d\d:\d\d:\d\d(\.\d+)?(([Zz])|(\+|-)\d\d:?\d\d)?$')
+
+    def _parseDatetime(self, d):
+        if d is None:
+            return None
+        m = ApiClient._iso8601Regex.match(d)
+        if not m:
+            raise Exception('datetime regex match failed "%s"' % d)
+        timesep, microsecond, offset, zulu, plusminus = m.groups()
+        format = self._iso8601Format(timesep, microsecond, offset, zulu)
+        if offset and not zulu:
+            d = d.rsplit(sep=plusminus, maxsplit=1)[0] + offset.replace(':', '')
+        return datetime.datetime.strptime(d, format)
+
+    def deserialize(self, obj, objClass):
+        """Derialize a JSON string into an object.
+
+        Args:
+            obj -- string or object to be deserialized
+            objClass -- class literal for deserialzied object, or string
+                of class name
+        Returns:
+            object -- deserialized object"""
+
+        # Have to accept objClass as string or actual type. Type could be a
+        # native Python type, or one of the model classes.
+        if type(objClass) == str:
+            if 'list[' in objClass:
+                match = re.match('list\[(.*)\]', objClass)
+                subClass = match.group(1)
+                return [self.deserialize(subObj, subClass) for subObj in obj]
+
+            if (objClass in ['int', 'float', 'dict', 'list', 'str', 'bool', 'datetime']):
+                objClass = eval(objClass)
+            else:  # not a native type, must be model class
+                objClass = eval(objClass + '.' + objClass)
+
+        if objClass in [int, float, dict, list, str, bool]:
+            return objClass(obj)
+        elif objClass == datetime:
+            return self._parseDatetime(obj)
+
+        instance = objClass()
+
+        for attr, attrType in instance.swaggerTypes.items():
+
+            if attr in obj:
+                value = obj[attr]
+                if attrType in ['str', 'int', 'float', 'bool']:
+                    attrType = eval(attrType)
+                    try:
+                        value = attrType(value)
+                    except UnicodeEncodeError:
+                        value = unicode(value)
+                    except TypeError:
+                        value = value
+                    setattr(instance, attr, value)
+                elif (attrType == 'datetime'):
+                    setattr(instance, attr, self._parseDatetime(value))
+                elif 'list[' in attrType:
+                    match = re.match('list\[(.*)\]', attrType)
+                    subClass = match.group(1)
+                    subValues = []
+                    if not value:
+                        setattr(instance, attr, None)
+                    else:
+                        for subValue in value:
+                            subValues.append(self.deserialize(subValue,
+                                                              subClass))
+                    setattr(instance, attr, subValues)
+                else:
+                    setattr(instance, attr, self.deserialize(value,
+                                                             attrType))
+
+        return instance
+
+
+class MethodRequest(urllib.request.Request):
+
+    def __init__(self, *args, **kwargs):
+        """Construct a MethodRequest. Usage is the same as for
+        `urllib.Request` except it also takes an optional `method`
+        keyword argument. If supplied, `method` will be used instead of
+        the default."""
+
+        if 'method' in kwargs:
+            self.method = kwargs.pop('method')
+        return urllib.request.Request.__init__(self, *args, **kwargs)
+
+    def get_method(self):
+        return getattr(self, 'method', urllib.request.Request.get_method(self))

samples/client/petstore/python3/client/user_api.py

@@ -0,0 +1,414 @@
+#!/usr/bin/env python
+"""
+UserApi.py
+Copyright 2015 Reverb Technologies, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually.
+"""
+import sys
+import os
+
+from .models import *
+
+
+class UserApi(object):
+
+    def __init__(self, apiClient):
+      self.apiClient = apiClient
+
+    
+    
+    def createUser(self, **kwargs):
+        """Create user
+
+        Args:
+            
+            body, User: Created user object (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method createUser" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def createUsersWithArrayInput(self, **kwargs):
+        """Creates list of users with given input array
+
+        Args:
+            
+            body, list[User]: List of user object (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method createUsersWithArrayInput" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/createWithArray'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def createUsersWithListInput(self, **kwargs):
+        """Creates list of users with given input array
+
+        Args:
+            
+            body, list[User]: List of user object (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method createUsersWithListInput" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/createWithList'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'POST'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def loginUser(self, **kwargs):
+        """Logs user into the system
+
+        Args:
+            
+            username, str: The user name for login (required)
+            
+            
+            password, str: The password for login in clear text (required)
+            
+            
+        
+        Returns: str
+        """
+
+        allParams = ['username', 'password']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method loginUser" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/login'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+        if ('username' in params):
+            queryParams['username'] = self.apiClient.toPathValue(params['username'])
+        
+        if ('password' in params):
+            queryParams['password'] = self.apiClient.toPathValue(params['password'])
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'str')
+        return responseObject
+        
+        
+        
+    
+    def logoutUser(self, **kwargs):
+        """Logs out current logged in user session
+
+        Args:
+            
+        
+        Returns: 
+        """
+
+        allParams = []
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method logoutUser" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/logout'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def getUserByName(self, **kwargs):
+        """Get user by user name
+
+        Args:
+            
+            username, str: The name that needs to be fetched. Use user1 for testing.  (required)
+            
+            
+        
+        Returns: User
+        """
+
+        allParams = ['username']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method getUserByName" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/{username}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'GET'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('username' in params):
+            replacement = str(self.apiClient.toPathValue(params['username']))
+            resourcePath = resourcePath.replace('{' + 'username' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        if not response:
+            return None
+
+        responseObject = self.apiClient.deserialize(response, 'User')
+        return responseObject
+        
+        
+        
+    
+    def updateUser(self, **kwargs):
+        """Updated user
+
+        Args:
+            
+            username, str: name that need to be deleted (required)
+            
+            
+            body, User: Updated user object (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['username', 'body']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method updateUser" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/{username}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'PUT'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('username' in params):
+            replacement = str(self.apiClient.toPathValue(params['username']))
+            resourcePath = resourcePath.replace('{' + 'username' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+    def deleteUser(self, **kwargs):
+        """Delete user
+
+        Args:
+            
+            username, str: The name that needs to be deleted (required)
+            
+            
+        
+        Returns: 
+        """
+
+        allParams = ['username']
+
+        params = locals()
+        for (key, val) in params['kwargs'].items():
+            if key not in allParams:
+                raise TypeError("Got an unexpected keyword argument '%s' to method deleteUser" % key)
+            params[key] = val
+        del params['kwargs']
+
+        resourcePath = '/user/{username}'
+        resourcePath = resourcePath.replace('{format}', 'json')
+        method = 'DELETE'
+
+        queryParams = {}
+        headerParams = {}
+
+        
+
+        
+
+        
+        if ('username' in params):
+            replacement = str(self.apiClient.toPathValue(params['username']))
+            resourcePath = resourcePath.replace('{' + 'username' + '}',
+                                                replacement)
+        
+
+        postData = (params['body'] if 'body' in params else None)
+
+        response = self.apiClient.callAPI(resourcePath, method, queryParams,
+                                          postData, headerParams)
+
+        
+        
+        
+    
+
+