Ejemplo n.º 1
0
def correlation_matrix(request):
    global ppd
    corr = pd.DataFrame(ppd.get_corr_matrix())
    feature_name = ppd.getFeatureName()
    corr.insert(0, column='Feature Name', value=feature_name)

    # Pagination
    page = request.GET.get('page', 1)
    page_size = request.GET.get('page_size', 12)
    try:
        page = int(page)
        page_size = int(page_size)

    except ValueError:
        raise Http404
    paginator = Paginator(tuple(corr.T.items()), page_size, request=request)

    try:
        corr_page = paginator.page(page)
    except PageNotAnInteger:
        corr_page = paginator.page(1)
    except EmptyPage:
        corr_page = paginator.page(paginator.num_pages)

    context = {
        'corr': corr_page,
        'features_name': ppd.getFeatureName(),
    }
    return render(request,
                  'data_cleaning_app/correlation_matrix.html',
                  context=context)
Ejemplo n.º 2
0
def view_data(request):
    global ppd
    print("View data function")
    data = pd.DataFrame(ppd.get_data())

    # Pagination
    page = request.GET.get('page', 1)
    page_size = request.GET.get('page_size', 10)

    try:
        page = int(page)
        page_size = int(page_size)

    except ValueError:
        raise Http404

    view_data_paginator = Paginator(tuple(data.T.items()),
                                    page_size,
                                    request=request)
    try:
        data_status_page = view_data_paginator.page(page)
    except PageNotAnInteger:
        print("Page not an integer")
        data_status_page = view_data_paginator.page(1)
    except EmptyPage:
        print("empty page")
        data_status_page = view_data_paginator.page(
            view_data_paginator.num_pages)

    context = {
        'data': data_status_page,
        'features_name': ppd.getFeatureName(),
        'num_page': view_data_paginator.num_pages
    }
    return render(request, 'data_cleaning_app/view_data.html', context=context)
Ejemplo n.º 3
0
def feature_scaling(request):
    global ppd
    if request.method == 'POST':
        print("feature scaling post")
        if 'normalization' in request.POST:
            ppd.set_normalization('all')

        if 'standardization' in request.POST:
            ppd.set_standardization('all')

        if 'scaling_btn' in request.POST:
            scaling_feature = Feature_Scaling_form(request.POST)
            print(scaling_feature.errors)
            if scaling_feature.is_valid():
                print(request.POST)
                print(request.POST['scaling_btn'])
                scaling_method = scaling_feature.cleaned_data['scaling_method']
                if scaling_method == 'normalization':
                    ppd.set_normalization(request.POST['scaling_btn'])
                else:
                    ppd.set_standardization(request.POST['scaling_btn'])

    # Pagination
    page = request.GET.get('page', 1)
    page_size = request.GET.get('page_size', 10)
    try:
        page = int(page)
        page_size = int(page_size)

    except ValueError:
        raise Http404
    paginator = Paginator(tuple(ppd.get_numeric_features_name()),
                          page_size,
                          request=request)

    try:
        feature_name_page = paginator.page(page)
    except PageNotAnInteger:
        feature_name_page = paginator.page(1)
    except EmptyPage:
        feature_name_page = paginator.page(paginator.num_pages)

    scaling_feature = Feature_Scaling_form()

    context = {
        'scaling_feature': scaling_feature,
        'feature_name': feature_name_page,
        'num_page': paginator.num_pages,
        'have_missing': ppd.check_any_missing()
    }
    return render(request,
                  'data_cleaning_app/feature_scaling.html',
                  context=context)
Ejemplo n.º 4
0
def search(request):
    query = request.GET.get('q', '')
    if query:
        qset = (
            Q(title__icontains=query)
        )
        results = FlashCard.objects.filter(qset).distinct().order_by('-vote')
    else:
        results = []
    try:
        page = request.GET.get('page', 1)
    except PageNotAnInteger:
        page = 1

    # Provide Paginator with the request object for complete querystring generation
    p = Paginator(results, 5, request=request)
    flashcards = p.page(page)
    paging = isNeedPaging(results, 5)
    return render_to_response("flashcard/search.html", {
        'results': results,
        'query': query ,
		'user':request.user,
        'flashcards': flashcards,
        'paging': paging,
    }, context_instance=RequestContext(request))
Ejemplo n.º 5
0
    def build_page(self):
        """
        override to use pure_pagination
        """
        try:
            page_no = int(self.request.GET.get('page', 1))
        except (TypeError, ValueError):
            raise Http404("Not a valid number for page.")

        if page_no < 1:
            raise Http404("Pages should be 1 or greater.")

        start_offset = (page_no - 1) * self.results_per_page

        self.results[start_offset:start_offset + self.results_per_page]
        it = SearchQuerySetSafeIterator(self.results)

        paginator = Paginator(it, self.results_per_page)

        try:
            page = paginator.page(page_no)
        except InvalidPage:
            raise Http404("No such page!")

        return (paginator, page)
Ejemplo n.º 6
0
    def get(self, request):
        all_teachers = Teacher.objects.all()

        # 总共有多少老师使用count进行统计
        teacher_nums = all_teachers.count()

        # 搜索功能
        search_keywords = request.GET.get('keywords', '')
        if search_keywords:
            all_teachers = all_teachers.filter(name__contains=search_keywords)

        # 人气排序
        sort = request.GET.get('sort', '')
        if sort:
            if sort == 'hot':
                all_teachers = all_teachers.order_by('-click_nums')

        # 讲师排行榜
        sorted_teacher = Teacher.objects.all().order_by('-click_nums')[:3]

        # 进行分页
        try:
            page = request.GET.get('page', 1)
        except PageNotAnInteger:
            page = 1
        p = Paginator(all_teachers, 1, request=request)
        teachers = p.page(page)

        return render(
            request, 'teacher/teachers-list.html', {
                'all_teachers': teachers,
                'teacher_nums': teacher_nums,
                'sorted_teacher': sorted_teacher,
                'sort': sort,
            })
Ejemplo n.º 7
0
    def get(self, request):
        #所有的课程
        all_courses = Course.objects.all().order_by('-add_time')
        # 热门课程推荐
        hot_courses = Course.objects.all().order_by('-click_nums')[:3]
        # 搜索功能
        search_keywords = request.GET.get('keywords', '')
        if search_keywords:
            # icontains是包含的意思(不区分大小写)
            # Q可以实现多个字段,之间是or的关系
            all_courses = all_courses.filter(Q(name__icontains=search_keywords) | Q(desc__icontains=search_keywords) | Q(
                    detail__icontains=search_keywords))
        # 排序
        sort = request.GET.get('sort', "")
        if sort:
            if sort == "students":
                all_courses = all_courses.order_by("-students")
            elif sort == "hot":
                all_courses = all_courses.order_by("-click_nums")
        # 分页
        try:
            page = request.GET.get('page', 1)
        except PageNotAnInteger:
            page = 1
        p = Paginator(all_courses,2 , request=request)
        courses = p.page(page)
        return render(request, "../templates/course/course-list.html", {
            "all_courses":courses,  #当前页码对象
            'sort': sort, #排序
            'hot_courses':hot_courses,  #热度列表

        })
Ejemplo n.º 8
0
Archivo: views.py Proyecto: UET/Ewikis
def home_page(request):
    try:
        profile = get_object_or_404(Profile, user=request.user)
        interests_page =  Paginator(profile.interest.all().order_by('-like'),5,request=request)
        interests = interests_page.page(request.GET.get('page',1))
        variables = RequestContext(request, {'profile': profile, 'interests':interests})
    except:
        variables = RequestContext(request, {'user': request.user})
    return render_to_response('home.html', variables)
Ejemplo n.º 9
0
Archivo: views.py Proyecto: UET/Ewikis
def user_profile_page(request, username):
    vuser=get_object_or_404(User, username=username)
    profile=get_object_or_404(Profile, user=vuser)
    interests_page =  Paginator(profile.interest.all().order_by('-like'),5,request=request)
    interests = interests_page.page(request.GET.get('page',1))
    cuser=request.user
    is_owner=False
    if vuser == cuser:
        is_owner=True
    variables=RequestContext(request, {'profile':profile, 'is_owner':is_owner, 'interests':interests})
    return render_to_response('user_profile.html', variables)
Ejemplo n.º 10
0
    def get(self, request):
        all_message = UserMessage.objects.filter(user=request.user.id)

        try:
            page = request.GET.get('page', 1)
        except PageNotAnInteger:
            page = 1
        p = Paginator(all_message, 4, request=request)
        messages = p.page(page)
        return render(request, 'users/usercenter-message.html', {
            'messages': messages,
        })
Ejemplo n.º 11
0
 def get(self, request, *args, **kwargs):
     kw = request.GET.get('kw')
     all_article = Article.objects.filter(Q(title__icontains=kw)|Q(content__icontains=kw)).distinct() # distinct():去重
     tags = Tag.objects.filter(is_delete=False).all()  # 所有标签    标签云
     try:
         page = request.GET.get('page', 1)
     except PageNotAnInteger:
         page = 1
     p = Paginator(all_article, per_page=1, request=request)
     # 注意:跟前端遍历一样
     all_article = p.page(page)
     return render(request, 'list.html', locals())
Ejemplo n.º 12
0
 def get(self,request,*args,**kwargs):
     new_commets =super().get(request,*args,**kwargs)
     all_article = Article.objects.filter(is_delete=False).all() # 查所有文章
     tags = Tag.objects.filter(is_delete=False).all()  # 所有标签    标签云
     try:
         page = request.GET.get('page', 1)
     except PageNotAnInteger:
         page = 1
     p = Paginator(all_article, per_page=1, request=request)
     # 注意:跟前端遍历一样
     all_article = p.page(page)
     return render(request,'list.html',locals())
Ejemplo n.º 13
0
def view_title(request,sub):
    objects = FlashCard.objects.filter(subject=sub).order_by('-vote')
    try:
        page = request.GET.get('page', 1)
    except PageNotAnInteger:
        page = 1
    p = Paginator(objects, 5, request=request)
    flashcards = p.page(page)
    paging = isNeedPaging(objects, 5)
    return render_to_response('flashcard/viewtitle.html',{
		'flashcards':flashcards,
		'user':request.user,
        'paging': paging,
    },context_instance=RequestContext(request))
Ejemplo n.º 14
0
def user_flashcard(request, username):
    viewUser = get_object_or_404(User, username = username)
    flashcard_list = FlashCard.objects.filter(user = viewUser).order_by('-vote')
    try:
        page = request.GET.get('page', 1)
    except PageNotAnInteger:
        page = 1
    p = Paginator(flashcard_list, 10, request=request)
    flashcards = p.page(page)
    paging = isNeedPaging(flashcard_list, 10)
    return render_to_response('account/myflashcard.html', {'flashcards': flashcards,
                                                           'paging': paging,
                                                           'viewUser': viewUser,
                                                           'user':request.user})
Ejemplo n.º 15
0
 def test_last_page(self):
     paginator = Paginator(Article.objects.all(), 5)
     p = paginator.page(2)
     self.assertEqual(u"<Page 2 of 2>", unicode(p))
     self.assertQuerysetEqual(list(p.object_list), [
         "<Article: Article 6>", "<Article: Article 7>",
         "<Article: Article 8>", "<Article: Article 9>"
     ])
     self.assertFalse(p.has_next())
     self.assertTrue(p.has_previous())
     self.assertTrue(p.has_other_pages())
     self.assertEqual(3, p.next_page_number())
     self.assertEqual(1, p.previous_page_number())
     self.assertEqual(6, p.start_index())
     self.assertEqual(9, p.end_index())
Ejemplo n.º 16
0
 def test_first_page(self):
     paginator = Paginator(Article.objects.all(), 5)
     p = paginator.page(1)
     self.assertEqual(u"<Page 1 of 2>", unicode(p))
     self.assertQuerysetEqual(list(p.object_list), [
         "<Article: Article 1>", "<Article: Article 2>",
         "<Article: Article 3>", "<Article: Article 4>",
         "<Article: Article 5>"
     ])
     self.assertTrue(p.has_next())
     self.assertFalse(p.has_previous())
     self.assertTrue(p.has_other_pages())
     self.assertEqual(2, p.next_page_number())
     self.assertEqual(0, p.previous_page_number())
     self.assertEqual(1, p.start_index())
     self.assertEqual(5, p.end_index())
Ejemplo n.º 17
0
 def test_paginate_list(self):
     # Paginators work with regular lists/tuples, too -- not just with QuerySets.
     paginator = Paginator([1, 2, 3, 4, 5, 6, 7, 8, 9], 5)
     self.assertEqual(9, paginator.count)
     self.assertEqual(2, paginator.num_pages)
     self.assertEqual([1, 2], paginator.page_range)
     p = paginator.page(1)
     self.assertEqual(u"<Page 1 of 2>", unicode(p))
     self.assertEqual([1, 2, 3, 4, 5], p.object_list)
     self.assertTrue(p.has_next())
     self.assertFalse(p.has_previous())
     self.assertTrue(p.has_other_pages())
     self.assertEqual(2, p.next_page_number())
     self.assertEqual(0, p.previous_page_number())
     self.assertEqual(1, p.start_index())
     self.assertEqual(5, p.end_index())
Ejemplo n.º 18
0
 def test_paginate_list(self):
     # Paginators work with regular lists/tuples, too -- not just with QuerySets.
     paginator = Paginator([1, 2, 3, 4, 5, 6, 7, 8, 9], 5)
     self.assertEqual(9, paginator.count)
     self.assertEqual(2, paginator.num_pages)
     self.assertEqual([1, 2], paginator.page_range)
     p = paginator.page(1)
     self.assertEqual(u"<Page 1 of 2>", unicode(p))
     self.assertEqual([1, 2, 3, 4, 5], p.object_list)
     self.assertTrue(p.has_next())
     self.assertFalse(p.has_previous())
     self.assertTrue(p.has_other_pages())
     self.assertEqual(2, p.next_page_number())
     self.assertEqual(0, p.previous_page_number())
     self.assertEqual(1, p.start_index())
     self.assertEqual(5, p.end_index())
Ejemplo n.º 19
0
 def get(self,request,*args,**kwargs):
     id = kwargs.get('id')
     new_commets = super().get(request, *args, **kwargs)
     tags = Tag.objects.filter(is_delete=False).all()  # 所有标签    标签云
     try:
         category = Category.objects.get(id=id)
         all_article = category.article_set.all() # 一对多  所有文章
         try:
             page = request.GET.get('page', 1)
         except PageNotAnInteger:
             page = 1
         p = Paginator(all_article, per_page=1, request=request)
         # 注意:跟前端遍历一样
         all_article = p.page(page)
         return render(request, 'list.html', locals())
     except Category.DoesNotExist:
         return render(request, '404.html')
Ejemplo n.º 20
0
 def test_last_page(self):
     paginator = Paginator(Article.objects.all(), 5)
     p = paginator.page(2)
     self.assertEqual(u"<Page 2 of 2>", unicode(p))
     self.assertQuerysetEqual(list(p.object_list), [
         "<Article: Article 6>",
         "<Article: Article 7>",
         "<Article: Article 8>",
         "<Article: Article 9>"
     ])
     self.assertFalse(p.has_next())
     self.assertTrue(p.has_previous())
     self.assertTrue(p.has_other_pages())
     self.assertEqual(3, p.next_page_number())
     self.assertEqual(1, p.previous_page_number())
     self.assertEqual(6, p.start_index())
     self.assertEqual(9, p.end_index())
Ejemplo n.º 21
0
    def build_page(self):
        try:
            page_no = int(self.request.GET.get("page", 1))
        except (TypeError, ValueError):
            raise Http404("Not a valid number for page.")

        if page_no < 1:
            raise Http404("Pages should be 1 or greater.")

        paginator = Paginator(self.results, self.results_per_page, request=self.request)

        try:
            page = paginator.page(page_no)
        except InvalidPage:
            raise Http404("No such page!")

        return paginator, page
Ejemplo n.º 22
0
 def test_first_page(self):
     paginator = Paginator(Article.objects.all(), 5)
     p = paginator.page(1)
     self.assertEqual(u"<Page 1 of 2>", unicode(p))
     self.assertQuerysetEqual(list(p.object_list), [
         "<Article: Article 1>",
         "<Article: Article 2>",
         "<Article: Article 3>",
         "<Article: Article 4>",
         "<Article: Article 5>"
     ])
     self.assertTrue(p.has_next())
     self.assertFalse(p.has_previous())
     self.assertTrue(p.has_other_pages())
     self.assertEqual(2, p.next_page_number())
     self.assertEqual(0, p.previous_page_number())
     self.assertEqual(1, p.start_index())
     self.assertEqual(5, p.end_index())
Ejemplo n.º 23
0
    def get(self, request):
        user = request.user
        all_messages = UserMessage.objects.filter(user=user.id)
        paginator = Paginator(all_messages, 2)
        page_num = request.GET.get('page', 1)
        messages = paginator.page(page_num)

        # pages = messages.pages
        # number = messages.number
        # messages = {
        #     'number': page_num,
        #     'pages': pages,
        #     'object_list': page_messages.object_list
        # }

        return render(request, 'usercenter-message.html', {
            'messages': messages,
            'MEDIA_URL': settings.MEDIA_URL,
        })
Ejemplo n.º 24
0
def index(request):
    how_many_names = request.GET.get('how_many_names', 60)
    page_size = request.GET.get('page_size', 10)
    page_num = request.GET.get('page', 1)
    try:
        page_num = int(page_num)
        page_size = int(page_size)
        how_many_names = int(how_many_names)
    except ValueError:
        raise Http404

    selected_names = []
    total = len(names)
    for i in range(how_many_names):
        selected_names.append(names[randint(0, total - 1)])
    p = Paginator(selected_names, page_size, request=request)

    page = p.page(page_num)
    return render_to_response('index.html', {
        'page': page,
    })
Ejemplo n.º 25
0
    def get(self, request):
        all_message = UserMessage.objects.filter(
            user=request.user.id).order_by("-add_time")
        # 用户进入个人中心消息页面,清空未读消息记录
        all_unread_messages = UserMessage.objects.filter(user=request.user.id,
                                                         has_read=False)

        for all_unread_message in all_unread_messages:
            all_unread_message.has_read = True
            all_unread_message.save()
        #对消息进行分页
        # 尝试获取前台get请求传递过来的page参数
        # 如果是不合法的配置参数默认返回第一页
        try:
            page = request.GET.get("page", 1)
        except PageNotAnInteger:
            page = 1
        #这里从消息中取出五个出来,每页显示5个
        p = Paginator(all_message, 4)
        messages = p.page(page)
        return render(request, 'usercenter-message.html', {
            "messages": messages,
        })
Ejemplo n.º 26
0
    def get(self, request):
        all_courses = Course.objects.all().order_by('-add_time')
        # 热门课程推荐
        hot_courses = Course.objects.all().order_by('-click_nums')[:3]

        # 搜索功能
        search_keywords = request.GET.get('keywords', '')
        if search_keywords:
            # 在name字段进行操作,做like语句的操作,i代表不区分大小写
            # or操作使用Q
            all_courses = all_courses.filter(
                Q(name__icontains=search_keywords)
                | Q(desc__icontains=search_keywords)
                | Q(detail__icontains=search_keywords))

        # 排序
        sort = request.GET.get('sort', '')
        if sort:
            if sort == 'students':
                all_courses = all_courses.order_by('-students')
            elif sort == 'hot':
                all_courses = all_courses.order_by('-click_nums')

        # 分页
        try:
            page = request.GET.get('page', 1)
        except PageNotAnInteger:
            page = 1
        p = Paginator(all_courses, 5, request=request)
        courses = p.page(page)
        print('courses=', courses.object_list)

        return render(request, 'course/course-list.html', {
            'all_courses': courses,
            'sort': sort,
            'hot_courses': hot_courses,
        })
Ejemplo n.º 27
0
Archivo: wiki.py Proyecto: UET/Ewikis
def filterWiki(request,subject,Wiki):
	sub_Subject ={'MATH','LANGUAGE', 'SCIENCE', 'HISTORY'}
	subject = subject.upper()
	if subject == 'ALL':
		wiki =  Paginator(Wiki.objects.all().order_by('-like'),5,request=request)
		return wiki.page(request.GET.get('page',1))
	elif subject in sub_Subject:
		if subject == "MATH":
			wiki = Paginator(Wiki.objects.filter(
				Q(subject='ALEGEBRA')|
				Q(subject='ARITHMETIC')|
				Q(subject='CALCULUS')|
				Q(subject='GEOMETRY')|
				Q(subject='STATISTICS')
				).order_by('-like')[:5],5,request=request)
			return wiki.page(request.GET.get('page',1))
		if subject == "HISTORY":
			wiki = Paginator(Wiki.objects.filter(
			Q(subject='CHINA')|
			Q(subject='VIETNAM')|
			Q(subject='WORLD')
			).order_by('-like')[:5],5,request=request)
			return wiki.page(request.GET.get('page',1))
		if subject == "LANGUAGE":
			wiki = Paginator(Wiki.objects.filter(
			Q(subject='CHINESE')|
			Q(subject='VIETNAMESE')|
			Q(subject='ENGLISH')|
			Q(subject='SPANISH')
			).order_by('-like')[:5],5,request=request)
			return wiki.page(request.GET.get('page',1))
		if subject == "SCIENCE":
			wiki = Paginator(Wiki.objects.filter(
			Q(subject='BIOLOGY')|
			Q(subject='CHEMISTRY')|
			Q(subject='EARTHSICENCE')|
			Q(subject='PHYSICS')|
			Q(subject='PSYCHOLOGY')|
			Q(subject='MEDICINE')
			).order_by('-like')[:5],5,request=request)
			return wiki.page(request.GET.get('page',1))
	else:
		wiki =  Paginator(Wiki.objects.filter(subject = subject).order_by('-like'),5,request=request)
		return wiki.page(request.GET.get('page',1))
Ejemplo n.º 28
0
    def get(self, request):
        # 取出所有课程机构
        all_orgs = CourseOrg.objects.all()
        org_onums = all_orgs.count()
        # 取出所有城市
        all_citys = CityDict.objects.all()

        # 机构搜索功能
        search_keywords = request.GET.get('keywords', '')
        if search_keywords:
            # 在name字段进行操作,做like语句的操作,i代表不区分大小写
            # or操作使用Q
            all_orgs = all_orgs.filter(
                Q(name__icontains=search_keywords)
                | Q(desc__icontains=search_keywords))

        # 城市筛选
        city_id = request.GET.get('city', '')
        print('city_id=', city_id)
        if city_id:
            all_orgs = all_orgs.filter(city_id=int(city_id))

        # 类别筛选
        category = request.GET.get('ct', '')
        if category:
            all_orgs = all_orgs.filter(category=category)

        # 有多少家机构
        org_nums = all_orgs.count()
        print('org_nums=', org_nums)

        # 热门课程机构排名
        hot_orgs = all_orgs.order_by('-click_nums')[:3]

        # 学习人数和课程教师赛选
        sort = request.GET.get('sort', '')
        if sort:
            if sort == 'students':
                all_orgs = all_orgs.order_by('-students')
            elif sort == 'courses':
                all_orgs = all_orgs.order_by('-course_nums')

        # 对课程机构进行分页
        # 尝试获取前台get请求传递过来的page参数
        # 如果是不合法的配置参数默认返回第一页
        try:
            page = request.GET.get('page', 1)
        except PageNotAnInteger:
            page = 1
        # 这里指从allorg中取出五个出来,每页显示5个
        p = Paginator(all_orgs, 5)
        orgs = p.page(page)
        print('orgs=', orgs.number)

        return render(
            request, 'organization/org-list.html', {
                'all_orgs': orgs,
                'all_citys': all_citys,
                'org_onums': org_onums,
                'city_id': city_id,
                'category': category,
                'hot_orgs': hot_orgs,
            })
Ejemplo n.º 29
0
def list_comments(request, ctype=None, object_pk=None, target=None, root_only=True):

    try:
        page = request.GET.get('page', 1)
        sort = request.GET.get('sort', 'oldest')

    except PageNotAnInteger:
        page = 1
        sort = 'oldest'

    if isinstance(ctype, basestring):
        ctype = _lookup_content_type(ctype)
    if isinstance(ctype, ContentType) and object_pk:
        try:
            if target is None:
                target = ctype.model_class().objects.get(pk=object_pk)

            root_qs = utils.get_query_set(ctype=ctype, object_pk=object_pk, root_only=True)
            sorter = CommentSorter(root_qs, request=request, anchor=COMMENTS_ANCHOR)
            paginator = Paginator(sorter.sort(), COMMENTS_PER_PAGE, request=request, anchor=COMMENTS_ANCHOR)
            root_qs = paginator.page(page)

            child_qs = utils.get_root_children(root_qs, ctype, object_pk)
            if child_qs:
                child_sorter = CommentSorter(child_qs, request=request, anchor=COMMENTS_ANCHOR)
                child_qs = child_sorter.sort()

            tree = utils.cache_comment_children(root_qs, child_qs)
        except Exception as e:
             e = e
             raise Http404


        try:
            comments = tree
            #sorter.group(comments)

        except EmptyPage:
            raise Http404

        #if sorter.grouped:
        #   template_file = 'teaser_list_grouped.html'
        #else:
        #    template_file = 'teaser_list.html'


        template_search_list = [
            "comments/%s/%s/list.html" % (ctype.app_label, ctype.model),
            "comments/%s/list.html" % ctype.app_label,
            "comments/list.html"
        ]

        return TemplateResponse(request, template_search_list, {
            "comment_list" : comments,
            "obj" : target,
            'sort_dropdown': sorter.sort_dropdown,
        })


        #posts_output = render_to_string('posts/includes/' + template_file, {
        #'posts': posts,
        #'request': request,
        #'sorter' : sorter,
        #'sort_dropdown': sorter.sort_dropdown,
        #'subsort_dropdown': sorter.subsort_dropdown
        #})

    else:
        return HttpResponse('')
Ejemplo n.º 30
0
def data_cleaning(request):
    print("data_cleaning function:")
    global ppd
    if request.method == 'POST':
        print("Post Data")
        print(request.POST)
        if 'binary_btn' in request.POST:
            binary_form = BinaryEncoder(request.POST)
            if binary_form.is_valid():
                ppd.binary_encode(
                    binary_form.cleaned_data['feature_name'],
                    binary_form.cleaned_data['verbose'],
                    binary_form.cleaned_data['drop_invariant'],
                    binary_form.cleaned_data['return_df'],
                    binary_form.cleaned_data['handle_unknown'],
                    binary_form.cleaned_data['handle_missing'],
                )
                print("Binary Encoder")
                print(binary_form.cleaned_data['feature_name'])
                print("Success")

        if 'hashing_btn' in request.POST:
            hashing_form = HashingEncoder(request.POST)
            if hashing_form.is_valid():
                ppd.hashing_encoder(
                    hashing_form.cleaned_data['feature_name'],
                    hashing_form.cleaned_data['verbose'],
                    hashing_form.cleaned_data['drop_invariant'],
                    hashing_form.cleaned_data['return_df'],
                    hashing_form.cleaned_data['hash_method'],
                    hashing_form.cleaned_data['max_process'],
                    hashing_form.cleaned_data['max_sample'])
                print("Hashing Encoder")
                print(hashing_form.cleaned_data['feature_name'])
                print("Hashing Encoder Form Success")

        if 'leave_one_out_btn' in request.POST:
            leave_one_out_form = LeaveOneOutEncoder(request.POST)
            if leave_one_out_form.is_valid():
                ppd.leave_one_out_encode(
                    leave_one_out_form.cleaned_data['feature_name'],
                    leave_one_out_form.cleaned_data['verbose'],
                    leave_one_out_form.cleaned_data['drop_invariant'],
                    leave_one_out_form.cleaned_data['return_df'],
                    leave_one_out_form.cleaned_data['handle_unknown'],
                    leave_one_out_form.cleaned_data['handle_missing'],
                    leave_one_out_form.cleaned_data['sigma'],
                )
                print("Leave One Out Encoder")
                print(leave_one_out_form.cleaned_data['feature_name'])
                print("Leave One Out Encoder Form Success")

        if 'one_hot_btn' in request.POST:
            one_hot_form = OneHotEncoder(request.POST)
            if one_hot_form.is_valid():
                ppd.one_hot_encode(one_hot_form.cleaned_data['feature_name'],
                                   one_hot_form.cleaned_data['drop'],
                                   one_hot_form.cleaned_data['sparse'],
                                   one_hot_form.cleaned_data['dType'],
                                   one_hot_form.cleaned_data['handle_unknown'])
                print("One hot Encoder")
                print(request.POST)
                print("One Hot Encoder Form Success")

        if 'sum_btn' in request.POST:
            sum_form = SumEncoder(request.POST)
            if sum_form.is_valid():
                ppd.sum_encode(sum_form.cleaned_data['feature_name'],
                               sum_form.cleaned_data['verbose'],
                               sum_form.cleaned_data['drop_invariant'],
                               sum_form.cleaned_data['return_df'],
                               sum_form.cleaned_data['handle_unknown'],
                               sum_form.cleaned_data['handle_missing'])
                print("Sum Encoder")
                print(sum_form.cleaned_data['feature_name'])
                print("Sum Encoder Form Success")

        if 'target_btn' in request.POST:
            target_form = TargetEncoder(request.POST)
            if target_form.is_valid():
                ppd.target_encoder(target_form.cleaned_data['feature_name'],
                                   target_form.cleaned_data['verbose'],
                                   target_form.cleaned_data['drop_invariant'],
                                   target_form.cleaned_data['return_df'],
                                   target_form.cleaned_data['handle_unknown'],
                                   target_form.cleaned_data['min_sample_leaf'],
                                   target_form.cleaned_data['smoothing'])
                print("Target Encoder")
                print(target_form.cleaned_data['feature_name'])
                print("Target Encoder Form Success")

        if 'label_btn' in request.POST:
            label_form = LabelEncoder(request.POST)
            if label_form.is_valid():
                ppd.auto_label_encoding(
                    label_form.cleaned_data['feature_name'])

    auto_form = AutoEncoderForm()
    manual_form = ManualEncoderForm()
    one_hot = OneHotEncoder()
    binary = BinaryEncoder()
    hashing = HashingEncoder()
    sum_encoder = SumEncoder()
    target = TargetEncoder()
    leave_one_out = LeaveOneOutEncoder()
    label = LabelEncoder()

    # Pagination
    page = request.GET.get('page', 1)
    page_size = request.GET.get('page_size', 10)
    try:
        page = int(page)
        page_size = int(page_size)

    except ValueError:
        raise Http404

    paginator = Paginator(tuple(ppd.get_category_list().T.items()),
                          page_size,
                          request=request)

    try:
        feature_name_page = paginator.page(page)
    except PageNotAnInteger:
        feature_name_page = paginator.page(1)
    except EmptyPage:
        feature_name_page = paginator.page(paginator.num_pages)

    context = {
        'auto_form': auto_form,
        'manual_form': manual_form,
        'category_feature_name': feature_name_page,
        'num_page': paginator.num_pages,
        'label': label,
        'one_hot': one_hot,
        'binary': binary,
        'hashing': hashing,
        'sum': sum_encoder,
        'target': target,
        'leave_one_out': leave_one_out,
        'have_missing': ppd.check_any_missing()
    }

    return render(request,
                  'data_cleaning_app/data_cleaning.html',
                  context=context)
Ejemplo n.º 31
0
def status(request):
    global file_name
    global ppd
    print("status function")

    if request.method == 'POST':
        if 'btn_status_remove_feature' in request.POST:
            feature = request.POST['btn_status_remove_feature']
            print("Remove ")
            print(feature)
            ppd.remove_feature(feature)

    feature_status = pd.DataFrame(ppd.get_feature_status())
    feature_status_dict = {}
    feature_status_columns = feature_status.axes[1]

    for i in feature_status.axes[0]:
        feature_status_dict[i] = {
            'attr_type':
            feature_status.at[i, 'attr_type'],
            'n_unique_val':
            feature_status.at[i, 'n_unique_val'],
            'number_of_missing':
            feature_status.at[i, 'number_of_missing'],
            'percentage_of_missing':
            feature_status.at[i, 'percentage_of_missing'],
            'mean':
            feature_status.at[i, 'Mean'],
            'median':
            feature_status.at[i, 'Median'],
            'variance':
            feature_status.at[i, 'Variance'],
            'standard_deviation':
            feature_status.at[i, 'Standard Deviation'],
            'category_stat':
            ppd.get_category_stat(i)
            if feature_status.at[i, 'attr_type'] == 'category' else None
        }

    # Pagination
    page = request.GET.get('page', 1)
    page_size = request.GET.get('page_size', 10)
    try:
        page = int(page)
        page_size = int(page_size)

    except ValueError:
        raise Http404
    status_paginator = Paginator(tuple(feature_status_dict.items()),
                                 page_size,
                                 request=request)
    try:
        feature_status_page = status_paginator.page(page)
    except PageNotAnInteger:
        feature_status_page = status_paginator.page(1)
    except EmptyPage:
        feature_status_page = status_paginator.page(status_paginator.num_pages)

    num_features_types = ppd.get_num_numeric_and_category_feature()
    num_missing = ppd.get_num_missing()
    context = {
        'feature_status': feature_status_page,
        'feature_status_columns': feature_status_columns,
        'num_page': status_paginator.num_pages,
        'num_rows': ppd.getDataShape()[0],
        'num_cols': ppd.getDataShape()[1],
        'num_numeric_features': num_features_types[0],
        'num_category_features': num_features_types[1],
        'num_missing': num_missing[0],
        'percent_missing': num_missing[1]
    }
    return render(request, 'data_cleaning_app/status.html', context=context)