def get_top_words(request, n):
    url = request  # так привычнее
    try:
        r = requests.get(url)
        r.encoding = 'utf-8'
    except MissingSchema:
        print('Bad url - no schema')
        return HttpResponse(status_code=404,
                            data=json.dumps({'Failed': 'bad request'}))
    except requests.exceptions.InvalidURL:
        print('Bad url')
        return HttpResponse(status_code=404,
                            data=json.dumps({'Failed': 'bad request'}))
    except requests.exceptions.ConnectionError:
        print('Bad url')
        return HttpResponse(status_code=404,
                            data=json.dumps({'Failed': 'bad request'}))

    soup = BeautifulSoup(r.text, 'html.parser')
    lst_of_words = soup.get_text().split()
    lst_cleared_1_stage = list(
        map(lambda x: x.strip('()[]/.,!?<>=;:').lower(), lst_of_words))
    lst_cleared_2_stage = list(
        filter(lambda x: len(x) > 1 and x not in stop_words,
               lst_cleared_1_stage))
    dict_of_popular_words = dict(Counter(lst_cleared_2_stage).most_common(n))
    response = json.dumps(dict_of_popular_words, ensure_ascii=False)
    return HttpResponse(data=response)
예제 #2
0
 def send_response(url, func=func_server, conn=conn, lock=lock):
     try:
         response = func(url)
         data_response = response.data
         status_code = response.status_code
         if data_response:
             lock.acquire()
             global count_url
             count_url += 1
             conn.sendall(data_response)
             # self.conn.sendall(JsonResponse(data={'message': self.message}).data)
             lock.release()
         else:
             status_code = 404
             conn.sendall(
                 HttpResponse(status_code=404,
                              data={
                                  'error': '404',
                                  'message': 'not found'
                              }).data)
             logging.error(f"404 {url}")
     except Exception as e:
         status_code = 404
         conn.sendall(
             HttpResponse(status_code=404,
                          data={
                              'error': '404',
                              'message': 'not found'
                          }).data)
         logging.error(f"404 {url} {e}")
     print(f"Get data from <{url}> status code {status_code}\n")
예제 #3
0
def get_user_by_id(user_id):
    try:
        user = session.query(User).filter_by(id=int(user_id)).one()
    except:
        return HttpResponse("USER_NOT_FOUND", 404)

    return HttpResponse(UserDto().dump(user), 200)
예제 #4
0
def create_user(user_dto):
    try:

        if user_dto['password'] ==None:
            return HttpResponse("INVALID_INPUT", 405)

        user = User(**user_dto)
    except:
        return HttpResponse("INVALID_INPUT", 405)

    session.add(user)
    session.commit()
    return HttpResponse("USER_CREATED", 201)
예제 #5
0
    def run(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.bind((self.address, self.port))
        sock.listen(5)

        connection, address = sock.accept()
        try:
            connection.settimeout(5)
            buf = connection.recv(1024)
            req = HttpRequest(buf)
            res = HttpResponse()

            if self._resource_exists(req.target) != False:
                target = self._resource_exists(req.target)
                if DEBUG:
                    print target
                with open(target, 'r') as f:
                    res.setBody(f.read())
                res.setStatus(200)
            else:
                res.setStatus(404)

            connection.send(res.__str__())
            if DEBUG:
                print req
                print res
        except socket.timeout:
            print 'timeout'
        finally:
            connection.close()

        sock.close()
예제 #6
0
def update_wallet(wallet_id, wallet_dto):
    try:
        wallet = session.query(Wallet).filter_by(id=int(wallet_id)).one()
    except:
        return HttpResponse("WALLET_NOT_FOUND", 404)

    try:
        if wallet_dto.get('balance', -100):
            update_amount = int(wallet_dto['balance'])
            if update_amount <= 0:
                return HttpResponse("BAD_AMOUNT", 405)
            else:
                wallet.balance += int(wallet_dto['balance'])
        if wallet_dto.get('is_default', None):
            wallet.is_default = wallet_dto['is_default']
    except:
        return HttpResponse("INVALID_INPUT", 405)

    session.commit()
    return HttpResponse("WALLET_UPDATED", 200)
예제 #7
0
def update_user(user_id, data):
    try:
        user = session.query(User).filter_by(id=int(user_id)).one()
    except:
        return HttpResponse("NOT_FOUND", 404)

    try:
        if data.get('first_name', None):
            user.first_name = data['first_name']
        if data.get('last_name', None):
            user.last_name = data['last_name']
        if data.get('user_name', None):
            user.user_name = data['user_name']
        if data.get('password', None):
            user.password = data['password']
    except:
        return HttpResponse("INVALID_INPUT", 405)
    session.commit()

    return HttpResponse("USER_UPDATED", 200)
예제 #8
0
파일: main.py 프로젝트: sprucerooth/surfer
def start():
    socket_in = _create_socket()

    while True:
        client_socket, client_address = socket_in.accept()
        print(f"Established connection with client: {client_address}")
        print("Waiting for message from client...")

        raw_request = client_socket.recv(REQ_BUFFER_SIZE)
        print(f"Message received. Attempting to parse...")

        try:
            request = HttpRequest(raw_request)
            response = HttpResponse.ok(request)
        except InvalidHttpRequestException as e:
            response = HttpResponse.bad_request(e)

        client_socket.send(response.serialize())
        client_socket.close()
        print("Socket closed.")
예제 #9
0
def get_default_wallet(attribute, transaction_dto):
    try:
        print(int(transaction_dto[attribute]))
        wallet = session.query(Wallet) \
            .filter_by(owner_id=int(transaction_dto[attribute])) \
            .filter_by(is_default=True) \
            .one()
        return wallet
    except:
        formatted = attribute.split('_')
        message = f'{formatted[0]} wallet was not found'
        return HttpResponse(message, 404)
예제 #10
0
 def read_from_client(self, ed, connections, requests, responses, fileno):
     # handle input data
     try:
         data = connections[fileno].recv(1024)
         req = requests[fileno]
         req.add_data(data)
         if req.is_ready:
             ed.modify(fileno, select.EPOLLOUT)
             responses[fileno] = HttpResponse(req, self.rtdir,
                                              self.srv_name)
     except Exception as ex:
         logging.exception('erorror read:{}'.format(ex))
예제 #11
0
class HttpHandler(BaseHandler):
  '''
  Main Http Handler Class which will be extended by request handlers.
  '''
  def __call__(self,request,*args,**kwargs):
    """
    Works when controller executes mapped subclass
    """
    #super(BaseHandler,self).__call__(request)
    self._template = None
    self.response = HttpResponse()
    self.request = request
    self.report = Report()
    self.cookies = CookieHandler(self)
    self.init(*args,**kwargs)
    """
    Subclasses will have get and post methods to handle requests.
    This method executes these methods by "method" attribute of request object.
    """
    getattr(self,'post' if self.request.method=='POST' else 'get')(*args,**kwargs)
    if self.template:
      self.response.write(self.template.render())
    return self.response

  def init(self,*args): pass
  def get(self,*args,**kwargs): pass
  def post(self,*args,**kwargs): 
    self.get(*args,**kwargs)

  def redirect(self,url):
    self.response.status = '307 Temporary Redirect'
    self.response.headers['Location'] = url

  @property
  def template(self):
    return self._template
    
  @template.setter
  def template(self,template):
    self._template = template
예제 #12
0
def create_wallet(wallet_dto):
    try:
        user = session.query(User).filter_by(
            id=int(wallet_dto['user_id'])).one()
    except:
        return HttpResponse("NOT_FOUND", 404)

    wallets = session.query(Wallet).filter_by(
        owner_id=int(wallet_dto['user_id'])).all()

    if len(wallets) >= 1:
        wallet = Wallet(balance=0,
                        owner_id=wallet_dto['user_id'],
                        is_default=False)
    else:
        wallet = Wallet(balance=0,
                        owner_id=wallet_dto['user_id'],
                        is_default=True)

    session.add(wallet)
    session.commit()
    return HttpResponse("SUCCESSFULLY_CREATED_WALLET", 201)
예제 #13
0
def create_transaction(transaction_dto):
    if transaction_dto.get('amount') is not None:
        amount = int(transaction_dto['amount'])
        if amount <= 0:
            return HttpResponse("INVALID_AMOUNT", 405)
    else:
        return HttpResponse("AMOUNT_NOT_PRESENT", 405)

    sender_wallet = get_default_wallet('sender_id', transaction_dto)
    receiver_wallet = get_default_wallet('receiver_id', transaction_dto)
    if not isinstance(sender_wallet, Wallet) or not isinstance(receiver_wallet, Wallet):
        return receiver_wallet

    if sender_wallet.balance < amount:
        return HttpResponse("INSUFFICIENT_FUNDS", 405)

    transaction = Transaction(sender_id=int(transaction_dto['sender_id']), receiver_id=int(transaction_dto['receiver_id']), amount=amount, time_stamp=datetime.today())
    sender_wallet.balance = sender_wallet.balance - amount
    receiver_wallet.balance += amount

    session.add(transaction)
    session.commit()

    return HttpResponse(TransactionDto().dump(transaction), 201)
예제 #14
0
    def run(self):
        while True:
            content = self.q.get()

            try:
                response = self.func(content['data'])
                data_response = response.data
                status_code = response.status_code
                if data_response:
                    self.lock.acquire()
                    global count_url
                    count_url += 1
                    self.conn.sendall(data_response)
                    # self.conn.sendall(JsonResponse(data={'message': self.message}).data)
                    self.lock.release()
                else:
                    status_code = 404
                    self.conn.sendall(HttpResponse(status_code=404, data={'error': '404', 'message': 'not found'}).data)
                    logging.error(f"404 {content['data']}")
            except Exception as e:
                status_code = 404
                self.conn.sendall(HttpResponse(status_code=404, data={'error': '404', 'message': 'not found'}).data)
                logging.error(f"404 {content['data']} {e}")
            print(f"{status_code}\n")
예제 #15
0
    def process (self, http_request) -> HttpResponse:
        env = http_request.get_cgi_config()

        env.update({**self.__config, 'wsgi.input': io.StringIO(http_request.get_body())})

        headers = []
        def start_response (status, response_headers, exc_info = None):
            nonlocal headers
            headers = [status, response_headers]

        result = self.__application(env, start_response)

        status, response_headers = headers

        return HttpResponse(status, response_headers, result, env)
예제 #16
0
 def __call__(self,request,*args,**kwargs):
   """
   Works when controller executes mapped subclass
   """
   #super(BaseHandler,self).__call__(request)
   self._template = None
   self.response = HttpResponse()
   self.request = request
   self.report = Report()
   self.cookies = CookieHandler(self)
   self.init(*args,**kwargs)
   """
   Subclasses will have get and post methods to handle requests.
   This method executes these methods by "method" attribute of request object.
   """
   getattr(self,'post' if self.request.method=='POST' else 'get')(*args,**kwargs)
   if self.template:
     self.response.write(self.template.render())
   return self.response
예제 #17
0
def get_user_wallets(user_id):
    try:
        wallets = session.query(Wallet).filter_by(owner_id=int(user_id)).all()
    except:
        return HttpResponse("NO_WALLETS", 404)
    return HttpResponse(wallets_dto.dump(wallets), 200)