bot/views.py

import bot.uchat
from django.shortcuts import render
from .models import Language, Query, ParamModelForm, Param
from bot.forms import RenewBotForm, EditorForm, EditorListForm, ParamForm, ImportForm
from django.shortcuts import get_object_or_404
from django.http import HttpResponseRedirect
from django.urls import reverse
import datetime
from django.db import transaction
from openai import OpenAI
from django.contrib.auth.decorators import login_required, permission_required
import json

#bot.uchat.chroma_client.allow_reset = True

class chat(object): 
 ns = cs = "s0"
 reply = ctx = ""
 messages = context = []
 ctx_flag = True
 previous = ""
 oc = bot.uchat.oc
 def get_reply(self,jezik,query,max_results,flag):
  msg = query # + "Objasnite na " + jezik + ", "
  query_results = bot.uchat.collection.query(
     query_texts = [ msg ],
     n_results = max_results,
     where = { "$and": [ {"$and": [ { "$or": [ {"state": self.cs },  { "page": { "$nin": [ -1 ] } } ] } , { "used": False } ] } ,
               {"lang": jezik } ] },
  )
  if bot.uchat.DEBUG: print("Query results:\n", query_results, "jezik:", jezik)
  ln = len(query_results["documents"][0])
  if ln == 0:
      if bot.uchat.DEBUG: print("Odaberite drugi jezik")
      bot.uchat.collection.update(
         ids=[f"id{id}" for id in range(bot.uchat.collection.count())],
         metadatas=[{"used": False} for i in range(bot.uchat.collection.count())],
      )
      if len(self.messages)>0: self.messages = self.messages[0]
      new = reply = "Kako Vam još mogu pomoći?"
      self.ctx_flag = True
      self.ns = self.cs = "s0"
      return new
  else:
    context = []
    i_state = l_state = -1
    for n in range(ln):
       if query_results["distances"][0][n] < (0.05+(bot.uchat.max_distance+bot.uchat.min_distance)/2):
          context += [ query_results["documents"][0][n] ]
          if i_state<0:
             l_state += 1
             if query_results["metadatas"][0][n]['state'] != 'None':
                i_state = n
       else:
          if (query_results["metadatas"][0][n]['state'] != 'None') and (i_state<0):
             i_state = n
    if l_state<0:
       l_state = i_state = 0
       ctx = query_results["documents"][0][0] 
       if self.cs != 'None':
          for n in range(1,len(context)): ctx +=  ", " + context[n]
    else:
       ctx = context[l_state]
       for n in range(len(context)):
          if l_state != n:
             ctx +=  ", " + context[n]
    ctx += "."
  match jezik:
     case 'hrvatski':
        o_jezik = 'hrvatskom'
     case 'slovenački':
        o_jezik = 'slovenačkom'
     case 'srpski':
        o_jezik = 'srpskom'
     case 'makedonski':
        o_jezik = 'makedonskom'
  if query_results["documents"][0][i_state]=="###":
    self.ctx_flag = False
    new = reply = "Kako Vam još mogu pomoći?"
    if bot.uchat.DEBUG: print("!!!###!!!")
    return "Ne razumem, ili je u pitanju greška."
  else:
    if ((query_results["distances"][0][i_state] > bot.uchat.max_distance)) and (self.cs == 'None'):
       self.ctx_flag = False
       if bot.uchat.DEBUG: print("Malo je nejasno šta je problem..")
       bot.uchat.collection.update(
          ids=[f"id{id}" for id in range(bot.uchat.collection.count())],
          metadatas=[{"used": False} for i in range(bot.uchat.collection.count())],
       )
       if len(messages)>0: messsages = messages[0]
       reply = "Malo je nejasno šta je problem - kako Vam još mogu pomoći?"
       self.ns = self.cs = "s0"
       return reply
    elif (query_results["distances"][0][i_state] < bot.uchat.min_distance):
       if self.cs != "None":
          self.ctx_flag = False
       else:
          self.ctx_flag = True
       new = reply=query_results["documents"][0][i_state]
    else:
       self.ctx_flag = True
       # reply=query_results["documents"][0][i_state]
    if (len(msg) < bot.uchat.min_len/4) or flag: self.ctx_flag = False
    id = query_results["ids"][0]
    meta = query_results["metadatas"][0]
    # ovo treba usloviti potrebnom input var ako treba
    if (meta[i_state]["state"] not in ['','s99']): meta[0]["used"] = True
    bot.uchat.collection.update( ids=id, metadatas=meta)
    self.ns = query_results["metadatas"][0][i_state]["next"]
    if self.messages==[]:
       self.messages = [ {"role": "system", "content": bot.uchat.system[jezik]} ]
       new_message = {"role": "user", "content": f"{msg} " + bot.uchat.msg_content[jezik] + " " + ctx + ". "}
    else:
       if self.ctx_flag:
          new_message = {"role": "user", "content": f"{msg}. " + bot.uchat.msg_content[jezik] + " " + ctx + ". "}
       else:
          new_message = {"role": "user", "content": f"{msg}."}
    self.messages.append(new_message)
    print("messages=", self.messages)
    if query_results["distances"][0][i_state] > bot.uchat.min_distance:
       completion = bot.uchat.oc.chat.completions.create(
          model = bot.uchat.model_id,
          messages=self.messages,
          temperature=bot.uchat.temperature,
          max_tokens=bot.uchat.max_tokens,
          top_p=bot.uchat.top_p,
          frequency_penalty=bot.uchat.frequency_penalty,
          presence_penalty=bot.uchat.presence_penalty,
          stop=["###","<|","|im_end|","|im_start|"],
          #   do_sample=True,
       )
       if bot.uchat.DEBUG: print('msg=' + new_message['content'] + "\nMessages:\n", self.messages, flush=True)
       new_message = {"role": "assistant", "content": ""}
       new=completion.choices[0].message.content
       if new==self.previous:
          if bot.uchat.DEBUG: print("Same!!!")
          bot.uchat.collection.update(
             ids=[f"id{id}" for id in range(bot.uchat.collection.count())],
             metadatas=[{"used": False} for i in range(bot.uchat.collection.count())],
          )
          new_message["content"] = new = self.previous = reply = "Kako Vam još mogu pomoći?"
          self.ns = self.cs = "s0"
          self.messages = self.messages[0]
       else:
          new_message["content"] += completion.choices[0].message.content
          self.previous = new_message["content"]
          if bot.uchat.DEBUG: print(new, end="", flush=True)
    else:
       new_message = {"role": "assistant", "content": ""}
       new_message["content"] = reply
       new = reply
    self.messages.append(new_message)
    # Prevođenje na druge jezike:
    #match o_jezik:
    #   case 'srpskom':
    #       pass
    #   case _ :
    #       new_message = {"role": "user", "content": f"Napiši to na {o_jezik} jeziku."}
    #       self.messages.append(new_message)
    #       completion = bot.uchat.oc.chat.completions.create(
    #          model = bot.uchat.model_id,
    #          messages=self.messages,
    #          temperature=bot.uchat.temperature,
    #          max_tokens=bot.uchat.max_tokens,
    #          top_p=bot.uchat.top_p,
    #          frequency_penalty=bot.uchat.frequency_penalty,
    #          presence_penalty=bot.uchat.presence_penalty,
    #          stop=None,
    #          #   do_sample=True,
    #       )
    #       new=completion.choices[0].message.content
    #       new_message = {"role": "user", "content": new}
    #       self.messages.append(new_message)
    if (self.ns!='None'):
      if (self.ns != self.cs): self.cs=self.ns 
  if self.cs=='None': self.cs='s0' ; self.ctx_flag = False
  return new

def selected(jez,str):
    if jez==str:
       return 'selected'
    else:
       return ' '

def index(request):
    #num_books = Book.objects.all().count()
    # Number of visits to this view, as counted in the session variable.
    chat_inst = chat()
    request.session.set_expiry(300)
    jezik = request.session.get('jezik', 'srpski')
    num_visits = request.session.get('num_visits', 1)
    if num_visits == 0:
        if bot.uchat.DEBUG: print("Debug: ")
    request.session['num_visits'] = num_visits+1
    reply = request.session.get("replies", "Zdravo, kako Vam mogu pomoći?")
    if request.method == 'POST':
        # Create a form instance and populate it with data from the request (binding):
        form = RenewBotForm(request.POST)
        if form.is_valid():
           request.session['query'] = query = form.cleaned_data['query']
           jezik = form.cleaned_data['jezik']
           request.session['jezik'] = jezik
           nr =  bot.uchat.max_results if num_visits < bot.uchat.max_results else 1+(num_visits % 2)
           #iif len(chat_inst.messages)>0:
           #    request.session['messages'] = chat_inst.messages if num_visits % 2 == 1 else chat_inst.messages[0:0]
           chat_inst.messages = request.session.get('messages',[])
           chat_inst.cs = request.session.get('cs','s0')
           chat_inst.ns = request.session.get('ns','s0')
           if bot.uchat.max_conv < len(chat_inst.messages):
              new_reply = chat_inst.get_reply(jezik, query, nr, True)
           else:
              new_reply = chat_inst.get_reply(jezik, query, nr, False)
           request.session['messages'] = chat_inst.messages
           request.session['ns'] = chat_inst.ns
           request.session['cs'] = chat_inst.cs
           request.session['replies'] = reply + "\nKorisnik: " + query + "\n\nOdgovor: " + new_reply + "\n"
#           q = QueryForm(request.POST)
           return HttpResponseRedirect(reverse("index"))
        else:
           if bot.uchat.DEBUG: print("Invalid form!", form.errors)
    else:
        form = RenewBotForm(initial={'query': 'Neki upit:'})
        query = request.session.get('query','...')
        jezik = request.session.get('jezik','srpski')
        #if len(chat_inst.messages)>0:
        #    request.session['messages'] = chat_inat.messages
        #else:
        #    request.session['messages'] = []
        return render(
        request,
        'index.html',
        context={
                 'num_visits': num_visits,
                 'reply': reply,
                 'selected_hr': selected(jezik,'hrvatski'),
                 'selected_sl': selected(jezik,'slovenački'),
                 'selected_sr': selected(jezik,'srpski'),
                 'selected_mk': selected(jezik,'makedonski'),
                }
    )

def reset(request):
    chat().messages = request.session.get('messages',[])
    chat().cs = "s0"
    chat().ns = "s0"
    chat().oc.close()
    bot.uchat.oc = oc = OpenAI(base_url="http://localhost:4891/v1", api_key="not-needed")
    ids = bot.uchat.collection.get()['ids']
    for id in ids: bot.uchat.collection.update(ids=[id], metadatas=[{'used': False}])
    jezik = request.session.get('jezik','srpski')
    request.session.flush()
    request.session['num_visits'] = 0
    return render(
        request,
        'index.html',
        context = {'num_visits': 0,
                   'reply': 'Kako Vam mogu još pomoći?',
                 'selected_hr': selected(jezik,'hrvatski'),
                 'selected_sl': selected(jezik,'slovenački'),
                 'selected_sr': selected(jezik,'srpski'),
                 'selected_mk': selected(jezik,'makedonski'),
                }
        )

def editor(request):
    #pagesize = 10
    if request.method == "POST":
        form = EditorListForm(request.POST)
        form.is_valid()
        try:
           request.session['id'] = f_id = form.cleaned_data['f_id']
        except:
           request.session['id'] = f_id = ""
        try:
           request.session['state'] = f_state = form.cleaned_data['f_state']
        except:
           request.session['state'] = f_state = ""
        try:
           request.session['next'] = f_next = form.cleaned_data['f_next']
        except:
           request.session['next'] = f_next = ""
        try:
           request.session['page'] = f_page = form.cleaned_data['f_page']
        except:
           request.session['page'] = f_page = ""
        try:
           request.session['jezik'] = f_jezik = form.cleaned_data['f_jezik']
        except:
           request.session['jezik'] = f_jezik = ""
        try:
           request.session['docu'] = f_docu = form.cleaned_data['f_docu']
        except:
           request.session['docu'] = f_docu = ""
        return HttpResponseRedirect(reverse('bot'))
    else:
       f_jezik = jezik = request.session.get('jezik','')
       f_state = request.session.get('state','')
       f_next = request.session.get('next','')
       f_page = request.session.get('page','')
       f_docu = request.session.get('docu','')
       f_id = request.session.get('id','')
       meta = {}
       if f_state != "":
              meta = {"state": f_state}
       if f_next != "":
          if meta == {}:
              meta = {"next": f_next}
          else:
              meta = { "$and": [ meta, {"next": f_next} ] }
       if f_page !="":
          if meta == {}:
              meta = {"page": f_page}
          else:
              meta = { "$and": [ meta , {"page": f_page} ] }
       if f_jezik != "":
           if meta == {}:
              meta = {"lang": f_jezik}
           else:
              meta = { "$and": [ meta, {"lang": f_jezik} ] }
       if f_id == "":
           if f_docu =="":
               ids = bot.uchat.collection.get(where=meta)['ids']
               documents = bot.uchat.collection.get(where=meta)['documents']
               states = bot.uchat.collection.get(where=meta)['metadatas']
           else:
               ids = bot.uchat.collection.get(where=meta, where_document={"$contains": f_docu })['ids']
               documents = bot.uchat.collection.get(where=meta, where_document={"$contains": f_docu })['documents']
               states = bot.uchat.collection.get(where=meta, where_document={"$contains": f_docu })['metadatas']
       else:
           if f_docu == "":
               ids = bot.uchat.collection.get(ids=[f'id{f_id}'], where=meta)['ids']
               documents = bot.uchat.collection.get(ids=[f'id{f_id}'], where=meta)['documents']
               states = bot.uchat.collection.get(ids=[f'id{f_id}'], where=meta)['metadatas']
           else:
               ids = bot.uchat.collection.get(ids=[f'id{f_id}'], where=meta, where_document={"$contains": f_docu })['ids']
               documents = bot.uchat.collection.get(ids=[f'id{f_id}'], where=meta, where_document={"$contains": f_docu })['documents']
               states = bot.uchat.collection.get(ids=[f'id{f_id}'], where=meta, where_document={"$contains": f_docu })['metadatas']
       cnt = 0
       nr = len(documents)
       id_docs = []
       for doc in documents:
            try:
                lang = states[cnt]['lang']
            except:
                lang = "srpski"
            id_docs += [ [ids[cnt], states[cnt]['state'], states[cnt]['next'], states[cnt]['page'], lang, doc] ]
            cnt += 1
       id_docs.sort(key=lambda k: eval(k[0][2:]))
       return render(
           request,
           'index_editor.html',
           context = {'last': bot.uchat.last, 'nr': nr,
                 'id_docs': id_docs,
                 'documents': documents,
                 'id': "",
                 'selected_hr': selected(jezik,'hrvatski'),
                 'selected_sl': selected(jezik,'slovenački'),
                 'selected_sr': selected(jezik,'srpski'),
                 'selected_mk': selected(jezik,'makedonski'),
                 'f_id': f_id,
                 'f_state': f_state,
                 'f_next': f_next,
                 'f_page': f_page,
                 'f_docu': f_docu,
                 'f_jezik': f_jezik,
                }
        )

def get_id(coll):
    for i in range(coll.count()):
        id = coll.get(ids=f'id{i}')['ids']
        if id==[]:
            return i
    return coll.count()

def editor_id(request, pk, pk2):
    last = bot.uchat.last
    state = next = uris = ""
    used = False
    page = -1
    if request.method == "POST":
        form = EditorForm(request.POST)
        if form.is_valid():
            id = form.cleaned_data['id'][2:]
            state = form.cleaned_data['state']
            next = form.cleaned_data['next']
            used = json.loads(form.cleaned_data['used'].lower())
            page = form.cleaned_data['page']
            docu = form.cleaned_data['docu']
            source = form.cleaned_data['source']
            jezik = form.cleaned_data['jezik']
            #request.session['jezik'] = jezik
            meta = {'state': state, 'next': next, 'used': used, 'page': page, 'source': source, 'lang': jezik}
            try:
               if pk2==0:
                  bot.uchat.collection.update(
                      ids = f'id{pk}',
                      metadatas = meta,
                      documents = docu
                  )
                  return HttpResponseRedirect(reverse('bot')+f'{pk}/0')
               elif pk2==1:
                  if bot.uchat.last>1:
                      new = get_id(bot.uchat.collection)
                      bot.uchat.collection.add(
                          ids = f'id{new}',
                          metadatas = meta,
                          documents = docu
                      )
                      bot.uchat.last += 1
                  return HttpResponseRedirect(reverse('bot')+f'{new}/0')
               elif pk2==2:
                  bot.uchat.collection.delete(ids = f'id{pk}')
                  bot.uchat.last -= 1
                  return HttpResponseRedirect(reverse('bot'))
            except:
              if bot.uchat.DEBUG: print("Errors:", form.errors)
              return HttpResponseRedirect(reverse('bot'))
        else:
            if bot.uchat.DEBUG: print("Invalid form!", form.errors)
            return HttpResponseRedirect(reverse('bot')+f'{pk}/0')
    else:
       if last>0:
           doc = bot.uchat.collection.get(ids=[f'id{pk}'])
           state = doc['metadatas'][0]['state']
           next = doc['metadatas'][0]['next']
           used = doc['metadatas'][0]['used']
           page = doc['metadatas'][0]['page']
           docu = doc['documents'][0]
           source = doc['metadatas'][0]['source']
       try:
           jezik = doc['metadatas'][0]['lang']
       except:
           jezik = request.session.get('jezik','srpski')
       return render(
           request,
           'index_editor.html',
           context = {'last': bot.uchat.last, 'nr': "",
                 'state': state,
                 'next': next,
                 'used': used,
                 'page': page,
                 'docu': docu,
                 'source': source,
                 'id': pk,
                 'selected_hr': selected(jezik,'hrvatski'),
                 'selected_sl': selected(jezik,'slovenački'),
                 'selected_sr': selected(jezik,'srpski'),
                 'selected_mk': selected(jezik,'makedonski'),
                }
        )

def params_refresh(request):
    if request.method == "POST":
       form = ParamForm(request.POST)
       form.is_valid()
       request.session["jezik"] = form.cleaned_data['jezik']
       return HttpResponseRedirect(reverse('params'))
    else:
       return HttpResponseRedirect(reverse('params'))

def params(request):
    if request.method == "POST":
       form = ParamForm(request.POST)
       jezici = []
       edit_all = Param.objects.all()
       for edit in edit_all: jezici += [edit.jezik]
       mform = ParamModelForm(request.POST)
       try:
          form.is_valid()
          request.session["jezik"] = form.cleaned_data['jezik']
          jezik = request.session["jezik"]
          bot.uchat.ctxpre = form.cleaned_data['ctxpre']
       except:
          bot.uchat.ctxpre = ""
       try:
          bot.uchat.msg_content[jezik] = form.cleaned_data['msg_content']
       except:
          bot.uchat.msg_content[jezik] = ""
       try:
          bot.uchat.system[jezik] = form.cleaned_data['system']
          bot.uchat.min_len = form.cleaned_data['min_len']
          bot.uchat.CHUNK_SIZE = form.cleaned_data['CHUNK_SIZE']
          bot.uchat.CHUNK_OVERLAP = form.cleaned_data['CHUNK_OVERLAP']
          bot.uchat.max_results = form.cleaned_data['max_results']
          bot.uchat.EMBED_MODEL = form.cleaned_data['EMBED_MODEL']
          bot.uchat.model_id = form.cleaned_data['model_id']
          bot.uchat.max_conv = form.cleaned_data['max_conv']
          bot.uchat.min_distance = form.cleaned_data['min_distance']
          bot.uchat.max_distance = form.cleaned_data['max_distance']
          bot.uchat.temperature = form.cleaned_data['temperature']
          bot.uchat.max_tokens = form.cleaned_data['max_tokens']
          bot.uchat.top_p = form.cleaned_data['top_p']
          bot.uchat.frequency_penalty = form.cleaned_data['frequency_penalty']
          bot.uchat.presence_penalty = form.cleaned_data['presence_penalty']
          bot.uchat.DEBUG = json.loads(form.cleaned_data['DEBUG'].lower())
       except:
          if bot.uchat.DEBUG: print("Errors:", form.errors)
       if jezik in jezici:
          for edit in edit_all:
              if edit.jezik == jezik:
                 edit.system = bot.uchat.system[jezik]
                 edit.min_len = bot.uchat.min_len
                 edit.CHUNK_SIZE = bot.uchat.CHUNK_SIZE
                 edit.CHUNK_OVERLAP = bot.uchat.CHUNK_OVERLAP
                 edit.max_results = bot.uchat.max_results
                 edit.EMBED_MODEL = bot.uchat.EMBED_MODEL
                 edit.model_id = bot.uchat.model_id
                 edit.max_conv = bot.uchat.max_conv
                 edit.min_distance = bot.uchat.min_distance
                 edit.max_distance = bot.uchat.max_distance
                 edit.temperature = bot.uchat.temperature
                 edit.max_tokens = bot.uchat.max_tokens
                 edit.top_p = bot.uchat.top_p
                 edit.frequency_penalty = bot.uchat.frequency_penalty
                 edit.presence_penalty = bot.uchat.presence_penalty
                 edit.DEBUG = bot.uchat.DEBUG
                 edit.jezik = jezik
                 edit.msg_content = bot.uchat.msg_content[jezik]
                 edit.ctxpre = bot.uchat.ctxpre
                 edit.save()
       else:
          mform.save()
       return HttpResponseRedirect(reverse('params'))
    else:
       jezik = request.session.get('jezik','srpski')
       if jezik == '': jezik='srpski'
       edit_all = Param.objects.all()
       for edit in edit_all:
          if edit.jezik == jezik:
             bot.uchat.system[jezik] = edit.system
             bot.uchat.ctxpre = edit.ctxpre
             bot.uchat.msg_content[jezik] = edit.msg_content
             bot.uchat.min_len = edit.min_len
             bot.uchat.CHUNK_SIZE = edit.CHUNK_SIZE
             bot.uchat.CHUNK_OVERLAP = edit.CHUNK_OVERLAP
             bot.uchat.max_results = edit.max_results
             bot.uchat.EMBED_MODEL = edit.EMBED_MODEL
             bot.uchat.model_id = edit.model_id
             bot.uchat.min_distance = edit.min_distance
             bot.uchat.max_distance = edit.max_distance
             bot.uchat.max_conv = edit.max_conv
             bot.uchat.temperature = edit.temperature
             bot.uchat.top_p = edit.top_p
             bot.uchat.max_tokens = edit.max_tokens
             bot.uchat.presence_penalty = edit.presence_penalty
             bot.uchat.frequency_penalty = edit.frequency_penalty
             bot.uchat.DEBUG = edit.DEBUG
       return render(
          request,
          'index_params.html',
          context = {'system': bot.uchat.system[jezik],
                   'ctrpre': bot.uchat.ctxpre,
                   'msg_content': bot.uchat.msg_content[jezik],
                   'min_len': bot.uchat.min_len,
                   'CHUNK_SIZE': bot.uchat.CHUNK_SIZE,
                   'CHUNK_OVERLAP': bot.uchat.CHUNK_OVERLAP,
                   'max_results': bot.uchat.max_results,
                   'EMBED_MODEL': bot.uchat.EMBED_MODEL,   # "all-MiniLM-L6-v2",
                   'model_id': bot.uchat.model_id,         # model_id = "Yugo60-GPT-GGUF.Q4_K_M.gguf"
                   'max_conv': bot.uchat.max_conv,
                   'min_distance': bot.uchat.min_distance,
                   'max_distance': bot.uchat.max_distance,
                   'temperature': bot.uchat.temperature,
                   'max_tokens': bot.uchat.max_tokens,
                   'top_p': bot.uchat.top_p,
                   'frequency_penalty': bot.uchat.frequency_penalty,
                   'presence_penalty': bot.uchat.presence_penalty,
                   'DEBUG': bot.uchat.DEBUG,
                   'selected_hr': selected(jezik,'hrvatski'),
                   'selected_sl': selected(jezik,'slovenački'),
                   'selected_sr': selected(jezik,'srpski'),
                   'selected_mk': selected(jezik,'makedonski'),
                }
        )

def importPdf(request):
    if request.method == "POST":
       form = ImportForm(request.POST)
       if form.is_valid():
          path = form.cleaned_data['path']
          jezik = form.cleaned_data['jezik']
          request.session['jezik'] = jezik
          request.session['path'] = path
          l_last = bot.uchat.last
          try:
             bot.uchat.load_docs(path, jezik)
             l_last = bot.uchat.last - l_last
             request.session['answer'] = f"Importovano {l_last} delova PDF dokumenta."
          except:
             if bot.uchat.DEBUG: print("Došlo je do problema sa importom PDF fajla.")
             request.session['answer'] = "Došlo je do problema sa importom PDF fajla."
       return HttpResponseRedirect(reverse('importpdf'))
    else:
       jezik = request.session.get('jezik','srpski')
       path = request.session.get('path','/Users/profile/...')
       answer = request.session.get('answer','')
       return render(
          request,
          'index_import.html',
          context = {'path': path,
                   'answer': answer,
                   'selected_hr': selected(jezik,'hrvatski'),
                   'selected_sl': selected(jezik,'slovenački'),
                   'selected_sr': selected(jezik,'srpski'),
                   'selected_mk': selected(jezik,'makedonski'),
                }
       )

from django.views import generic

class BotView(generic.ListView):
    """View for a bot chat."""
    if bot.uchat.DEBUG: print ("Test!")
    model = Language 
    paginate_by = 5
    last = bot.uchat.last
    
class BotViewDetail(generic.DetailView):
    model = Language

##@login_required
##@permission_required('catalog.can_mark_returned', raise_exception=True)