View difference between Paste ID: 2gXe2QuZ and JW1j74nC

-import utility
+
-import http_request
+import psycopg2
 import time
-class Weather:
+
-    def __init__(self, config, city_name):
+
-        self.config = config
+class DataBase:
-        self.city = city_name
+    def __init__(self, settings):
-        self.weather_all_info = self.http_answer()
+
         # if 'host' not in settings:
-    def http_answer(self):
+        #     settings["host"] = 'localhost'
         if 'port' not in settings:
-        if 'address' not in self.config:
+            settings["port"] = ''
-            address = "api.openweathermap.org"
+        # if 'dbuser' not in settings:
         #     settings["dbuser"] = 'postgres'
-            address = self.config['http']["address"]
+        # try:
-        if 'uri' not in self.config:
+        #     self.settings = (
-            uri = "/data/2.5/weather"
+        #         "dbname='{dbname}' user='{dbuser}' host={host} password='{password}' port = '{port}'").format(
         #         dbname=settings['dbname'],
-            uri = self.config['http']['uri']
+        #         dbuser=settings['dbuser'],
         #         host=settings['host'],
-        city_info = utility.get_city_info(self.city)
+        #         password=settings['password'],
-        weather_all_info = http_request.HttpRequest(address, uri).get_info(city_info['API'], city_info['ID'])
+        #         port=settings['port'])
-        return weather_all_info
+        # except KeyError as er:
         #     print er, "is required parameter"
-    def get_weather(self, ):
+        #     exit()
-        fahrenheit = int(self.weather_all_info['main']['temp'])
+
-        celsius = utility.transfer_to_celsius(fahrenheit)
+        self.conn = None
-        return celsius
+        self.cursor = None
         # self.connect()
-    def get_info(self, ):
+        pass
-        return self.weather_all_info
+
     def start_transaction(self):
         answer = self.conn.autocommit
         if self.conn.autocommit:
             self.conn.autocommit = False
         return answer
 
     def end_transaction(self, transaction_started):
         if transaction_started:
             self.conn.commit()
             self.conn.autocommit = True
             print 'commit done'
 
     def roll_back(self, transaction_started):
         if transaction_started:
             self.conn.rollback()
             self.conn.commit()
             self.conn.autocommit = True
 
     def connect(self):
 
         try:
             self.conn = psycopg2.connect(self.settings)
         except psycopg2.Error as er:
             print er, "\n",
             exit()
         self.conn.autocommit = True
         self.cursor = self.conn.cursor()
         pass
 
     def disconnect(self):
         try:
             self.conn.close()
             self.conn = None
         except psycopg2.Error as er:
             print er
             exit()
         pass
 
     def get_info(self, table_name, wonted_data, search=None):
         # self.conn.autocommit = True
         self.cursor = self.conn.cursor()
         values = ""
 
         if isinstance(wonted_data, list):
             first = True
             for data in wonted_data:
                 if first:
                     values += data
                     first = None
                 else:
                     values += ',' + data
         else:
             values += wonted_data
 
         sql_request = 'SELECT ' + values + ' FROM ' + str(table_name) + ' WHERE deleted_at = 0'
 
         if search is not None:
             values = ()
             for key in search:
                 first = True
                 for val in search[key]:
 
                     values += (val,)
                     if first:
                         sql_request += " and " + key + " IN (%s"
                         first = None
                     else:
                         sql_request += ",%s"
                 sql_request += ")"
 
         try:
             # print sql_request
             # print (self.cursor.mogrify(sql_request, values).decode('utf8'))
             self.cursor.execute(sql_request, values)
             return self.cursor.fetchall()
         except TypeError as er:
             print er
             exit()
 
     def insert(self, table_name, dic):
         # self.conn.autocommit = True
         self.cursor = self.conn.cursor()
         columns = []
         values = ()
         for param in dic:
             columns.append(param)
             values += (dic[param],)
         sql_request = "INSERT INTO {table} ({param}) VALUES ({s}) returning id".format(
                  table=table_name,
                  param=', '.join(columns),
                  s=', '.join(["%s"]*len(values)))
         # print (self.cursor.mogrify(sql_request, values).decode('utf8'))
         self.cursor.execute(sql_request, values)
         return self.cursor.fetchone()[0]
         pass
 
     def update(self, table_name, dic, identifier):
         # self.conn.autocommit = True
         # self.cursor = self.conn.cursor()
         part_of_sql_request = []
         values = ()
         sql_request = "UPDATE " + table_name + " SET"
 
         for column in dic:
             part = " " + column + " = %s"
             values += (str(dic[column]),)
             part_of_sql_request.append(part)
         sql_request += ' ,'.join(part_of_sql_request)
         sql_request += " WHERE deleted_at = 0 and id IN( "
         # del part_of_sql_request[:]
         for id in identifier:
             sql_request += "%s,"
             values += (id,)
             # sql_request += ")"
             # part_of_sql_request.append(part)
         sql_request += ')'
         print sql_request
         print values
         # print (self.cursor.mogrify(sql_request, values).decode('utf8'))
 
         try:
             self.cursor.execute(sql_request, values)
             return self.cursor.fetchone()[0]
         except psycopg2.Error as er:
             print er
         pass
 
     def delete(self, table_name, identifiers):
 
         delete_data = {
          "deleted_at": time.time()
          }
         return self.update(table_name, delete_data, identifiers)
 
     def full_delete(self, table_name, identifiers):
         self.conn.autocommit = True
         self.cursor = self.conn.cursor()
         sql_request = "DELETE FROM {table} where id = %s".format(
             table=table_name)
         val = ()
         val += (identifiers,)
         try:
             self.cursor.execute(sql_request, val)
             return self.cursor.fetchone()[0]
         except psycopg2.Error as er:
             print er