# forms.py
class UploadPictureForm(forms.Form):
   
    name_image = forms.CharField(max_length=30, required=False)
    url = forms.URLField(required=False)
    img = forms.ImageField(required=False)

    def clean(self):
        cleaned_data = super(UploadPictureForm, self).clean()
        url = cleaned_data.get('url')
        img = cleaned_data.get('img')

        if (url and img) or (not url and not img):
            raise forms.ValidationError('плохо заполнили')
        
        return cleaned_data

# views.py

class UploadImage(FormView):
    form_class = UploadPictureForm
    template_name = 'resize_image/upload_image.html'
    success_url = reverse_lazy('image_list')
    
    def form_valid(self, form):
        if form.cleaned_data['img'] and not form.cleaned_data['url']:
            self.object = Picture.objects.create(
                upload_time = timezone.now(),
                img = form.cleaned_data['img'],
                name_image = form.cleaned_data['name_image'],)

        if form.cleaned_data['url'] and not form.cleaned_data['img']:
            pic_url = form.cleaned_data['url']
            name = urlparse(pic_url).path.split('/')[-1]
            response = requests.get(pic_url)
            picture = Picture()
            if response.status_code == 200:
                picture.img.save(name, ContentFile(response.content), save=False)
                picture.upload_time = timezone.now()
                picture.name_image = name
                picture.save()

<form action="" method="post" enctype="multipart/form-data">
     {% csrf_token %}
     
    <div class="form-group">
        <label>файл</label>
        {{ form.img }}
    </div>
    <div class="form-group">
        <label>Название</label>
        {{ form.name_image }}
    </div>
    <div class="form-group">
        <label>URL</label>
        {{ form.url }}
    </div>     

            
    <input type="submit" value="Submit" />
</form>

class Picture(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    img = models.ImageField(upload_to = 'uploads')
    name_image = models.CharField(max_length=30, verbose_name='Название изображения', blank=True, null=True)
    upload_time = models.DateTimeField(
        verbose_name='Время загрузки', blank=True, null=True)

class UploadImage(TemplateView):
    template_name = 'resize_image/upload_image.html'
    success_url = reverse_lazy('image_list')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['upload_pic_form'] = UploadPictureForm(
            self.request.POST, self.request.FILES )
        return context

    def post(self, request, *args, **kwargs):
        context = self.get_context_data()
        if context['upload_pic_form'].is_valid():
            pic = context['upload_pic_form'].save(commit=False)
            pic.save()

            return redirect('image_list')
        return JsonResponse({'errors': [context['upload_pic_form'].errors]})

urlpatterns = [
    path('', views.image_list, name='image_list'),
    path('upload/', views.UploadImage.as_view(), name='upload_image'),
    
]

{% extends 'resize_image/base.html' %} 
{% load staticfiles %}
 {% block content %}
 <form action="" method="post">
     {% csrf_token %}
     <div class="form-group">
            <label>файл</label>
            {{ upload_pic_form.img }}
        </div>
        <div class="form-group">
                <label>Название</label>
                {{ upload_pic_form.name_image }}
            </div>
    <input type="submit" value="Submit" />
</form>
        
 {% endblock %}

class CityManager(models.Manager):
    
    def with_dencity(self):
        return self.aggregate(dencity=Sum(F('population') /F('area'),output_field=FloatField()))


class CountryManager(models.Manager):
    
    def with_num_cities(self):
        return self.aggregate(num_cities=Count('cities'))

    def with_biggest_city_size(self):
        return self.aggregate(biggest_city_size=Max('cities__area'))


class Country(models.Model):
    objects = CountryManager()
    name = models.CharField(
        verbose_name='Название',
        max_length=255
    )

    def __str__(self):
        return '{}'.format(self.name)

class City(models.Model):
    objects = CityManager()
    country = models.ForeignKey(
        Country,
        verbose_name='Страна',
        related_name='cities',
        on_delete=models.CASCADE
    )
    name = models.CharField(
        verbose_name='Название',
        max_length=255
    )
    population = models.FloatField(
        verbose_name='Население'
    )
    area = models.FloatField(
        verbose_name='Площадь'
    )

    def __str__(self):
        return '{} {} {}'.format(self.name, self.population, self.area)

>>> c = City.objects.filter(name='Москва').aggregate(dencity=Sum(F('population') /F('area'),output_field=FloatField()))
>>> c
{'dencity': 10.0}
>>> c = City.objects.filter(name='Москва').with_dencity()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'QuerySet' object has no attribute 'with_dencity'
>>>
>>>
>>>
>>> c = Country.objects.filter(name='США').aggregate(num_cities=Count('cities'), biggest_city_size=Max('cities__area'))
>>> c
{'biggest_city_size': 700000.0, 'num_cities': 3}
>>> c = Country.objects.filter(name='США').with_num_cities().with_biggest_city_size()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'QuerySet' object has no attribute 'with_num_cities'
>>>

>>> c = Country.objects.get(name='США').with_num_cities().with_biggest_city_size()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'Country' object has no attribute 'with_num_cities'
>>>
>>>
>>>
>>> c = City.objects.get(name='Москва').with_dencity()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'City' object has no attribute 'with_dencity'
>>>
>>>
>>> c = Country.objects.get(name='США').with_num_cities()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'Country' object has no attribute 'with_num_cities'
>>>

@property
def get_rule(self):
    config = configparser.ConfigParser()
    config.read(path)
    title_rule = config.get(self.site_name, "title")
    return title_rule


print(self.get_rule)
'h1', {'class': 'title'}


[pravda.ru]
title = 'h1', {'class': 'title'}

print(self.get_page.find(self.get_rule))
None

print(self.get_page.find('h1', {'class': 'title'}))
<h1 class="title">text</h1>

rule = 'h1', {'class': 'title'}
print(self.get_page.find(rule))
<h1 class="title">text</h1>

rule = "'h1', {'class': 'title'}"
print(self.get_page.find(rule))
None

{% if item.reg_price < 50 %} 
       {% price = item.reg_price + (item.reg_price/100*11,73)+ (item.reg_price/100*24,6) %} 
               <td>{{ price }}</td> 
{% elif 50 <= item.reg_price <= 500 %} 
       {% price = item.reg_price + (item.reg_price/100*12) + (item.reg_price/100*24,9) %} 
               <td>{{ price }}</td> 
{% elif item.reg_price < 500 %} 
       {% price = item.reg_price + (item.reg_price/100*11,75) + (item.reg_price/100*24,3) %} 
               <td>{{ price }}</td> 
{% endif %}

{% elif target == 'reestr' %}
        <table class="table table-bordered table-condensed table" onselectstart="return false">
            <thead>
                <tr class="info">
                    <th class="text-center">Наименование</th>
                    <th class="text-center">Производитель</th>
                    <th class="text-center">Цена</th>
                </tr>
            </thead>
            <tbody>
                {% for item in item_list %}
                <tr class="active">
                    <td>{{ item.trade_name }}</td>
                    <td>{{ item.fabr_name}}</td>
                    <td>{{ item.reg_price }}</td> #здесь использовать условие
                </tr>
                {% endfor %}
            </tbody>
        </table>
        

class TblReestr(models.Model):
    id = models.IntegerField(primary_key=True)  # AutoField?
    ean13 = models.CharField(max_length=50, blank=True, null=True)
    reg_price = models.DecimalField(max_digits=15, decimal_places=2, blank=True, null=True)
    trade_name = models.CharField(max_length=1000, blank=True, null=True)
    fabr_name = models.CharField(max_length=500, blank=True, null=True)
    reg_data = models.DateField(blank=True, null=True)
    mnn_name = models.CharField(max_length=250, blank=True, null=True)
    valuta_name = models.CharField(max_length=20, blank=True, null=True)
    num_prikaz = models.CharField(max_length=30, blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'tbl_reestr'

def search(request):
    q = request.GET['q']
    target = request.GET['target']
    title = request.GET['title']
    if target == 'brak':
        item_list = TblBrak.objects.filter(trade_name__icontains=q)
    elif target == 'reestr':
        item_list = TblReestr.objects.filter(trade_name__icontains=q)

    INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'exchange_rates',
        'django_celery_beat',
        'django_celery_results',
        ]
    TIME_ZONE = 'Europe/Saratov'
    USE_I18N = True
    USE_L10N = True
    USE_TZ = True

    CELERY_BROKER_URL = 'redis://localhost:6379'
    CELERY_RESULT_BACKEND = 'redis://localhost:6379'
    CELERY_ACCEPT_CONTENT = ['application/json']
    CELERY_TASK_SERIALIZER = 'json'
    CELERY_RESULT_SERIALIZER = 'json'
    CELERY_TIMEZONE = TIME_ZONE 
    CELERY_ENABLE_UTC = False
    CELERYBEAT_SCHEDULER = 'django_celery_beat.schedulers:DatabaseScheduler'

    from celery.schedules import crontab
    app.conf.beat_schedule = {
        'add-every-5-seconds': {
            'task': 'save_exchange_rates_task',
            'schedule': 600.0,
            #'args': (16, 16)
        },
    }

class Currency(models.Model):
    name = models.CharField('Название валюты', max_length=20)
    price_usd = models.DecimalField(
        'Курс в долларах', max_digits=20, decimal_places=10, blank=True, null=True)
    last_updated = models.IntegerField('Последние обновление')


    def __str__(self):
        return '%s %s %s' % (self.name, self.price_usd, self.last_updated)

import os
import argparse
from PIL import Image


def create_parser():
    parser = argparse.ArgumentParser(
        description='Module for resize image.')
    parser.add_argument(
        'image', help='Where get the image.')
    parser.add_argument(
        '-w', '--width', type=int, help='Input new width image.')
    parser.add_argument(
        '-he', '--height', type=int, help='Input new height image.')
    parser.add_argument(
        '-sc', '--scale', type=float, help='Input how scale image.')
    parser.add_argument(
        '-out', '--output', help='Where to put the image.')
    return parser


def get_image(path_to_original):
    return Image.open(path_to_original)


def get_new_size(original_image,
                 new_width,
                 new_height,
                 scale):

    width_original, height_original = original_image.size
    if (new_width or new_height) and scale:
        raise RuntimeError('You must use scale without width or height!')
    elif new_width and new_height:
        if width_original / height_original != new_width / new_height:
            print('***The proportions do not match the original image.***')
        new_size = (new_width, new_height)
    elif new_width:
        height = int(new_width * height_original / width_original)
        new_size = (new_width, height)
    elif new_height:
        width = int(new_height * width_original / height_original)
        new_size = (width, new_height)
    elif scale:
        new_size = [round(scale * size) for size in original_image.size]
    else:
        raise RuntimeError('Width or height or scale required!')
    return new_size


def resize_image(original_image, new_size):
    return original_image.resize(new_size, Image.ANTIALIAS)


def chose_path_to_result(path_to_result, path_to_original, resized_image):
    if path_to_result:
        return path_to_result
    else:
        name_file, file_extension = os.path.splitext(path_to_original)

        created_path = '{}__{}x{}{}'.format(
            name_file,
            *resized_image.size,
            file_extension)
        return created_path


def save_image(resized_image, path_to_result):
    resized_image.save(path_to_result)


if __name__ == '__main__':
    parser = create_parser()
    namespace = parser.parse_args()

    path_to_original = namespace.image
    path_to_result = namespace.output
    image = get_image(path_to_original)
    new_size = get_new_size(image,
                            namespace.width,
                            namespace.height,
                            namespace.scale)

    resized_image = resize_image(image, new_size)

    chosen_path_to_result = chose_path_to_result(
        path_to_result, path_to_original, resized_image)

    save_image(resized_image, chosen_path_to_result)

import requests
import datetime
import sys


def get_trending_repositories(top_size):
    date_now = datetime.datetime.now()
    last_week = (date_now - datetime.timedelta(days=7)).strftime('%Y-%m-%d')

    filter_params = {'sort': 'stars',
                     'order': 'desc',
                     'page': '1'}
    filter_params['q'] = 'created:>{}'.format(last_week)
    filter_params['per_page'] = '{}'.format(top_size)
    url = 'https://api.github.com/search/repositories'
    repositories = requests.get(url, params=filter_params).json()['items']
    return repositories


def get_open_issues_amount(repositories):
    for number, repo in enumerate(repositories, 1):
        url = 'https://api.github.com/repos/{}/issues'.format(repo['full_name'])
        issues = requests.get(url).json()

        print('{}) \t open issues:{} \t {}'.format(
                    number, issues['number'], issues['repository_url']))


if __name__ == '__main__':
    if len(sys.argv) > 1:
        input_amount = sys.argv[1]
    else:
        input_amount = input('Enter amount repositories: ')
    filter_repositories = get_trending_repositories(input_amount)
    get_open_issues_amount(filter_repositories)

При попытке вывести на печать выдает ошибку:

Traceback (most recent call last):
  File "github_trending.py", line 49, in <module>
    get_open_issues_amount(filter_repositories)
  File "github_trending.py", line 28, in get_open_issues_amount
    number, issues['number'], issues['repository_url']))
TypeError: list indices must be integers or slices, not str

from math import sqrt


def get_roots(a, b, c):
    # a=0 makes the function linear, not quadratic.
    if a == 0:
        return None, None
    else:
        discriminant = b ** 2 - 4 * a * c
        # The square root is extracted only from a nonnegative number.
        if discriminant < 0:
            return None, None
        # If discriminant is 0, then roots of the quadratic equation 1.
        elif discriminant == 0:
            root1 = (-b - sqrt(discriminant)) / (2 * a)
            return root1, None
        # If discriminant > 0, then roots of the quadratic equation 2.
        else:
            root1 = (-b - sqrt(discriminant)) / (2 * a)
            root2 = (-b + sqrt(discriminant)) / (2 * a)
            return root1, root2

TypeError: 'NoneType' object is not iterable

def get_roots(a, b, c):
    discriminant = b ** 2 - 4 * a * c
    if discriminant < 0:
        return None, None
    else:
        roots(a, b, discriminant)

def roots(a, b, d):
    root1 = (-b - sqrt(d)) / (2 * a)
    root2 = (-b + sqrt(d)) / (2 * a)
    if d == 0:
        return root1, None
    else:
        return root1, root2

class Price(models.Model):
name_paiment = models.CharField('Название абонемента', max_length=20, unique=True)
whole_price = models.IntegerField('Цена', default=0, )
price_for_one_time = models.IntegerField('Цена за 1 посещение',)
number_of_visits = models.IntegerField('Количество посещений')

def __str__(self):
    return '%s %s' % (self.name_paiment, self.whole_price)

class Paiments(models.Model):
DISCOUNT = (
    ('0', 'нет скидки'),
    ('5', '5%'),
    ('10', '10%'),
    ('15', '15%'),
    ('20', '20%'),
    ('25', '25%'),
    ('30', '30%'),
)
paiment_of_student = models.ForeignKey(Student)
price_of_paiment = models.ForeignKey(Priсe, verbose_name='Название абонемента')
discount = models.IntegerField('Скидка в процентах', blank=True, default=0, choices=DISCOUNT) #ругается на значения, которые выбираешь.
begin_date = models.DateTimeField('Дата начала', default=timezone.now)
end_date = models.DateTimeField('Дата окончания')
finish_price = models.IntegerField(get_sale()) #пишет,что имя не определено.

def get_sale(self):
    '''Расчитать стоимость со скидкой'''
    end_price = int(self.price_of_paiment * (100 - self.discount) / 100)
    return end_price