
How to Upload a Webm Video From a Webcam to a Django Site Uploading a WebM video has many purposes including live chat, live video, verification, and other purposes. This software is all over the internet, and it is very useful for verification, entertainment, security, media, hobby, and other purposes. I hope you find this code useful and deploy it yourself, expanding on my ideas to create your own products. I'll explain how to implement basic security, which happens quickly and efficiently without very much cost.
# The models
# app/models.py
def get_file_path(instance, filename):
ext = filename.split('.')[-1]
filename = "%s.%s" % (uuid.uuid4(), ext)
return os.path.join('video/', filename)
class Camera(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True, related_name='camera')
frame = models.FileField(upload_to=get_file_path, null=True, blank=True)
last_frame = models.DateTimeField(default=timezone.now)
# The views
# app/views.py
@login_required
@csrf_exempt
def video(request):
cameras = VideoCamera.objects.filter(user=request.user)
camera = None
if cameras.count() == 0:
camera = VideoCamera.objects.create(user=request.user)
camera.save()
else:
camera = cameras.first()
if request.method == 'POST':
try:
form = CameraForm(request.POST, request.FILES, instance=camera)
camera = form.save()
except:
print(traceback.format_exc())
return HttpResponse(status=200)
return render(request, 'app/video.html', {'title': 'Video', 'form': CameraForm()})
# The forms
# app/forms.py
from django import forms
from app.models import Camera
class CameraForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
super(CameraForm, self).__init__(*args, **kwargs)
class Meta:
model = Camera
fields = ('frame',)
{% extends 'base.html' %}
{% block content %}
<div id="container">
<video autoplay="true" muted="true" id="video-element" width="100%"></video>
<form method="POST" enctype="multipart/form-data" id="live-form" style="position: absolute; display: none; visibility: hidden;">
{{ form }}
</form>
</div>
{% endblock %}
// The javascript
// templates/video.js
var form = document.getElementById('live-form');
var scale = 0.2;
var width = 1920 * scale;
var height = 1070 * scale
var video = document.getElementById('video-element');
var data;
var mediaRecorder;
var mediaChunks = [];
const VIDEO_INTERVAL = 5000; // The length of each packet to send, ideally more than 5000 ms (5 seconds)
function capture() {
mediaRecorder.stop(); // Stop to recod data
}
function startup() {
navigator.mediaDevices.getUserMedia({
video: {
width: {
ideal: width
},
height: {
ideal: height
}
},
audio: true
})
.then(function(stream) {
video.srcObject = stream;
video.play();
mediaRecorder = new MediaRecorder(stream);
mediaRecorder.addEventListener("dataavailable", event => {
mediaChunks.push(event.data);
var mediaData = clone(mediaChunks);
var file = new Blob(mediaData, {
'type': 'video/webm'
});
mediaChunks = [];
mediaRecorder.start();
var formdata = new FormData(form);
formdata.append('frame', new File([file], 'frame.webm'));
$.ajax({
url: window.location.href,
type: "POST",
data: formdata,
processData: false,
contentType: false,
}).done(function(respond) {
console.log(respond);
console.log("Sent frame");
});
});
setTimeout(function() {
setInterval(capture, VIDEO_INTERVAL);
}, 5000);
mediaRecorder.start();
}).catch(function(err) {
console.log("An error occurred: " + err);
});
}
startup();
# The API call
# live/apis.py
import requests
import json
params = {
'workflow': 'wfl_00000000000000000US',
'api_user': '000000000',
'api_secret': '000000000000000000'
}
def is_safe(video_path):
files = {'media': open(video_path, 'rb')}
r = requests.post('https://api.sightengine.com/1.0/video/check-workflow-sync.json', files=files, data=params)
output = json.loads(r.text)
if output['status'] == 'failure' or output['summary']['action'] == 'reject':
return False
return True
# And the models.py save call
...
def save(self, *args, **kwargs):
last_frame = self.frame
super(VideoCamera, self).save(*args, **kwargs)
if self.frame and self.frame != last_frame and not is_safe(self.frame.path):
self.frame = None
self.save()

How to identify and recognize faces using python with no APIs I use the below code to implement a login with face function on Uglek. The code works by assigning a user a face ID when they upload a face to their profile or go to log in, and then retrieving their account by image using the face ID. Here is the code
# face/face.py
from django.contrib.auth.models import User
import uuid
from .models import Face
import face_recognition
NUM_FACES = 9
def get_face_id(image_path):
image = face_recognition.load_image_file(image_path)
face_locations = face_recognition.face_locations(image)
if len(face_locations) > 1 or len(face_locations) < 1:
return False
for user in User.objects.filter(profile__enable_facial_recognition=True):
known_image = face_recognition.load_image_file(user.profile.face.path)
unknown_image = image
user_encoding = face_recognition.face_encodings(known_image)[0]
user_encodings = list()
user_encodings.append(user_encoding)
user_faces = Face.objects.filter(user=user).order_by('-timestamp')
for face in user_faces:
if open(face.image.path,"rb").read() == open(image_path,"rb").read():
return False
if user_faces.count() > NUM_FACES:
user_faces = user_faces[:NUM_FACES]
for face in user_faces:
image = face_recognition.load_image_file(face.image.path)
image_encoding = face_recognition.face_encodings(image)[0]
user_encodings.append(image_encoding)
unknown_encoding = face_recognition.face_encodings(unknown_image)[0]
results = face_recognition.compare_faces(user_encodings, unknown_encoding)
if results[0]:
return user.profile.uuid
return str(uuid.uuid4())

How to Identify Unique Faces with the Microsoft Azure Face API Using the Microsoft Azure Face API, you can assign unique faces a UUID and identify them for use in login, verification, or any other purpose. The following code accepts an image of a single face and returns a unique UUID representing that face. This has a huge application potential in internet security and could make some sites and businesses much more secure, by uniquely attributing faces to profiles within the apps or security solutions. Using the face API with Microsoft Azure is free for basic use, and isn't expensive otherwise. To install python modules for this code, run $ pip install --upgrade azure-cognitiveservices-vision-face $ pip install --upgrade Pillow The code is as follows.
# face/face.py
import asyncio
import io
import glob
import os
import sys
import time
import uuid
import requests
from urllib.parse import urlparse
from io import BytesIO
from PIL import Image, ImageDraw
from azure.cognitiveservices.vision.face import FaceClient
from msrest.authentication import CognitiveServicesCredentials
from azure.cognitiveservices.vision.face.models import TrainingStatusType, Person, QualityForRecognition
import json
# This key will serve all examples in this document.
KEY = "000000000000000000000000000000"
# This endpoint will be used in all examples in this quickstart.
ENDPOINT = "https://endpoint.api.cognitive.microsoft.com/"
PERSON_GROUP_ID = str("group") # assign a random ID (or name it anything)
def get_face_id(single_face_image_url):
# Create an authenticated FaceClient.
face_client = FaceClient(ENDPOINT, CognitiveServicesCredentials(KEY))
# Detect a face in an image that contains a single face
single_image_name = os.path.basename(single_face_image_url)
# We use detection model 3 to get better performance.
face_ids = []
# We use detection model 3 to get better performance, recognition model 4 to support quality for recognition attribute.
faces = face_client.face.detect_with_url(single_face_image_url, detection_model='detection_03') #, recognition_model='recognition_04', return_face_attributes=['qualityForRecognition'])
# Remove this line after initial call with first face (or you will get an error on the next call)
face_client.person_group.create(person_group_id=PERSON_GROUP_ID, name=PERSON_GROUP_ID)
for face in faces: # Add faces in the photo to a list
face_ids.append(face.face_id)
if len(faces) > 1: # Return if there are too many faces
return False
results = None
try:
results = face_client.face.identify(face_ids, PERSON_GROUP_ID) # Identify the face
except:
results = None
if not results: # Add the face if they are not identified
p = face_client.person_group_person.create(PERSON_GROUP_ID, uuid.uuid4()) # Identify them with a UUID
face_client.person_group_person.add_face_from_url(PERSON_GROUP_ID, p.person_id, single_face_image_url)
face_client.person_group.train(PERSON_GROUP_ID) # Training
while (True):
training_status = face_client.person_group.get_training_status(PERSON_GROUP_ID)
print("Training status: {}.".format(training_status.status))
print()
if (training_status.status is TrainingStatusType.succeeded):
break
elif (training_status.status is TrainingStatusType.failed):
sys.exit('Training the person group has failed.')
time.sleep(5)
results = face_client.face.identify(face_ids, PERSON_GROUP_ID)
if results and len(results) > 0: # Load their UUID
res = json.loads(str(results[0].candidates[0]).replace('\'',"\""))['person_id']
print(res)
return res # Return their UUID
return False # Or return false to indicate that no face was recognized.
f = 'uglek.com/media/face/1b195bf5-8150-4f84-931d-ef0f2a464d06.png'
print(get_face_id(f)) # Identify a face from this image

How to Generate a String from a Number in Python I use the following code to generate a string from a number under 1000. It is using simple arrays and if statements to generate a compound number as a string.
import math
n = ['one','two','three','four','five', 'six', 'seven', 'eight', 'nine', 'ten']
tn = ['eleven','twelve','thir','four','fif','six','seven','eigh','nine']
nn = ['ten','twenty','thirty','forty','fifty','sixty','seventy','eighty','ninety']
def number_to_string(num):
if not isinstance(num, int):
num = int(num) if num != '' else 'done'
if num == 'done':
return ''
if num == 0:
return ''
if num < 11:
return n[num-1]
if num < 20:
if num < 13:
return tn[num-11]
return tn[num-11] + 'teen'
if num < 100:
extra = '-'+n[num%10-1]
if num%10 == 0:
extra = ''
return nn[math.floor(num/10)-1]+extra
if num < 1000:
extra = '-'+n[num%10-1]
if num%10 == 0:
extra = ''
snum = str(num)
return n[math.floor(num/100)-1]+'-hundred'+ ('-' if number_to_string(int(snum[1:])) != '' else '') + number_to_string(int(snum[1:]))
if num < 10000:
snum = str(num)
return number_to_string(int(snum[:1])) + '-thousand' + ('-' if number_to_string(int(snum[1:])) != '' else '') +number_to_string(int(snum[1:]))
if num < 100000:
snum = str(num)
return number_to_string(int(snum[:2])) + '-thousand' + ('-' if number_to_string(int(snum[2:])) != '' else '') + number_to_string(int(snum[2:]))
if num < 1000000:
snum = str(num)
return number_to_string(snum[:len(snum) - 3]) + '-thousand' + ('-' if number_to_string(snum[len(snum)-3:]) != '' else '') + number_to_string(snum[len(snum)-3:])
if num < 1000000000:
snum = str(num)
return number_to_string(snum[:len(snum) - 6]) + '-million' + ('-' if number_to_string(snum[len(snum)-6:]) != '' else '') + number_to_string(snum[len(snum)-6:])
return 'number too large to compute!'
#for x in range(1,100000):
# print(number_to_string(x))
print(number_to_string(999999999))

Un dessin JavaScript - Tasse à café a créé ce simple dessin avec du code aujourd'hui comme photo de produit pour les nouveaux boutons. C'est un dessin d'une tasse à café, réalisé en utilisant des ovales et des rectangles. Le code qui le dessine est ci-dessous.
function init() {
var stage = new createjs.Stage("coffee");
var background = new createjs.Shape();
var yoffset = 40 ;
background.graphics.beginFill("DeepSkyBlue").drawRect(0, 0, 500, 500);
stage.addChild(arrière-plan);
var cercle = new createjs.Shape();
circle.graphics.beginFill("White").drawEllipse(10 + 300 + yoffset, 250 - 150, 120, 300);
stage.addChild(cercle);
var cercle3 = new createjs.Shape();
circle3.graphics.beginFill("DeepSkyBlue").drawEllipse(370, 90 + yoffset, 70, 240);
stage.addChild(cercle3);
var mug = new createjs.Shape();
mug.graphics.beginFill("White").drawRect(100, 60 + yoffset, 300, 300);
stage.addChild(tasse);
var cercle = new createjs.Shape();
circle.graphics.beginFill("White").drawEllipse(250 - 150, 10 + yoffset, 300, 100);
stage.addChild(cercle);
var cercle2 = new createjs.Shape();
circle2.graphics.beginFill("Brown").drawEllipse(250 - 130, 30 + yoffset, 260, 60);
stage.addChild(cercle2);
var cercle4 = new createjs.Shape();
circle4.graphics.beginFill("Blanc").drawEllipse(250 - 150, 10 + 300 + ydécalage, 300, 100);
stage.addChild(cercle4);
stage.update();
}

@Jasper_Holton, comme ça,

Comment créer un thème dynamique de lecture facile basé sur le lever et le coucher du soleil Ce code me permet d'afficher automatiquement les pages en mode clair ou sombre (avec des styles clairs ou foncés) selon que le soleil est en haut. interroge les informations de localisation et de fuseau horaire à l'aide d'une API. C'est un excellent moyen de rendre un site plus agréable à regarder la nuit. Une page Web avec beaucoup d'espace blanc peut être un peu difficile à utiliser la nuit, il est donc préférable d'avoir un processeur de contexte qui rend le site plus facile à lire la nuit. *(python)*# app/context_processors.py import pytz from astral import LocationInfo from astral.sun import sun [= NEWLINE=]def context_processor(context_data) tz = request.user.profile. ] = False # Ou sinon, mettez-le en lumière return context_data # users/middleware.py def simple_middleware(get_response): # One -temps de configuration et d'initialisation. def middleware(request) : User = get_user_model() if request.user.is_authenticated and hasattr(request.user, 'profile') : user = get_object_or_404(User, pkBesole002request.user.pk) # Mettre à jour l'heure de la dernière visite après la fin du traitement de la demande. last_ip = request.user.profile.ip request.user.profile.ip = get_client_ip(request) if request.user.profile.ip != last_ip : [= NEWLINE=] request.user.profile.timezone = get_timezone(request.user.profile.

Un correctif audio pratique pour les iframes à l'aide de jQuery C'est ainsi que lit l'audio en pause dans le document avec les iframes chargés afin que l'audio ne soit pas lu plus d'une fois dans le document. Ce correctif modifie le site pour corriger la double lecture audio dans plusieurs iframes. Ce code est inclus dans chaque iframe et dans le document principal.
$(function() {
$("audio").on("play", function() { // Lorsque chaque audio est lu dans le document principal [= NEWLINE=] $("audio", window.parent.document).not(this).each(function(index, audio) { // Récupère chaque audio qui n'est pas celui-ci
audio.pause( ); // Mettez-le en pause
});
lecture = ceci; // Enregistrez l'audio en cours de lecture
$("iframe", window.parent.document). each(function(index, iframe) { // Récupère tous les iframes du document parent
$(iframe).contents().find("audio").not(playing).each(function(index, audio ) { // Filtrer les audios qui ne devraient pas être lus (pas celui sur lequel nous avons cliqué)
audio.pause(); // Mettre en pause l'audio
});
}) ;
});
} );
@Jasper_Holton, comme ça,

Gestion détaillée des erreurs avec l'intergiciel Django Il s'agit d'un moyen simple de gérer les erreurs de manière détaillée à l'aide de l'intergiciel Django. À l'aide de ce middleware, vous pouvez afficher vos traces d'erreur sur des pages HTML personnalisées, au lieu d'utiliser les pages d'erreur du mode de débogage de Django. Voici comment fonctionne le code. Tout d'abord, un middleware pour obtenir l'erreur actuelle dans la vue du gestionnaire d'erreurs.
# app/middleware.py
from threading import local
import traceback
from django.utils.deprecation import MiddlewareMixin
_error = local() # Stocker l'erreur dans une
classe locale ExceptionVerboseMiddleware(MiddlewareMixin) :
def process_exception(self, request, exception) : # Processus l'exception
_error.value = traceback. format_exc() # Stocke la trace de la pile depuis traceback
def get_current_exception() : # Renvoie l'erreur
essai :
renvoie _error.value
sauf AttributeError :
return None
# app/views.py
def handler500(demande) :
data = {'title':'Error 500', 'error' : get_current_exception( )} # Mettez l'erreur dans le contexte, afin que nous puissions la restituer au modèle.
return render(request,'blog/500.html', data)
# project/settings.py
MIDDLEWARE = [
'...',
'app. middleware.ExceptionVerboseMiddleware',
'...'
]
# project/urls.py
handler500 = 'blog.views.handler500'
{{ error }}

How to Create an Infinitely Scrolling Django View Creating a pseudo-infinitely scrolling page for a Django site is fairly easy. It involves creating a main page that renders the first posts, a secondary page that renders more posts according to a page number, and using some basic JavaScript to load in more posts when the user scrolls to the bottom of the page. I created two views to handle the backend code.
# This view renders a scrollable page.
@vary_on_cookie
def scroll(request):
posts = Post.objects.filter(public=True).order_by('date_posted') # Get the posts for the first page
p = Paginator(posts, 10) # Paginate them
if request.user.is_authenticated: # Mark viewership if users are logged in
for post in p.page(p.num_pages):
if not post.viewers.filter(id=request.user.id).exists():
post.viewers.add(request.user)
context = { # Render the posts
'posts': p.page(p.num_pages),
'count': p.count,
'page_obj': p.get_page(p.num_pages),
'title': 'Scroll Posts',
'description': 'Scroll and see all the posts on Uglek here. This is the front page of Uglek.' + basedescription,
'dontshowsidebar': True,
'full': True,
'num_pages': p.num_pages,
}
response = render(request, 'blog/scroll.html', context)
if request.user.is_authenticated:
patch_cache_control(response, private=True) # Render private page
return response
# This view is simple. It renders the posts for each page as we scroll through them.
@vary_on_cookie
def scroll_page(request):
posts = Post.objects.filter(public=True).order_by('date_posted') # Get posts
p = Paginator(posts, 10) # Paginate them
page = p.num_pages - 1
if(request.GET.get('page', '') != ''): # Get the page from the querystring
page = int(request.GET.get('page', ''))
if request.user.is_authenticated: # Mark viewership if the user is logged in
for post in p.page(page):
if not post.viewers.filter(id=request.user.id).exists():
post.viewers.add(request.user)
context = {
'posts': p.page(page), # Render the posts
'count': p.count,
'page_obj': p.get_page(page),
}
response = render(request, 'blog/scrollpage.html', context)
if request.user.is_authenticated:
patch_cache_control(response, private=True) # Render private page
return response
var page = {{ num_pages }};
$(window).scroll(function() { // On scroll
if ($(window).scrollTop() + $(window).height() > $(document).height() - 5000) {
loadNext(); // Load new content
}
});
loadNext(); // Start by loading
var loading = false; // Keep track of whether we are loading
function loadNext() {
if (!loading && page > 1) { // If we are not loading already and there is another page
loading = true; // Mark that we are loading
page = page - 1; // Decrement the page (to load the next page)
var scrollContainer = document.getElementById("scroll-container"); // Get the container
const urlParams = new URLSearchParams(window.location.search);
var lang = '';
if (urlParams.get('lang') != null) {
lang = "&lang=" + urlParams.get('lang'); // Get the language
}
// Make a request to the next page with the language
const Http = new XMLHttpRequest();
const url = "https://uglek.com/scroll/page/?page=" + page + lang;
Http.responseType = 'text';
Http.onload = function() {
if (Http.readyState === Http.DONE) {
scrollContainer.insertAdjacentHTML("beforeend", Http.responseText);
loading = false;
}
};
Http.open("GET", url, true);
Http.send(null); // Send the request
}
}
// Load the next part of the site into the main site in an iframe
function loadNext() {
if (!loading && page > 1) {
loading = true;
page = page - 1;
var scrollContainer = document.getElementById("scroll-container");
const urlParams = new URLSearchParams(window.location.search);
var lang = '';
if (urlParams.get('lang') != null) {
lang = "&lang=" + urlParams.get('lang');
}
const url = "uglek.com/scroll/page/?page=" + page + lang;
var iframe = document.createElement('iframe');
iframe.src = url;
iframe.frameBorder = 0;
iframe.scrolling = 'no';
iframe.style.width = '100%';
iframe.classList.add('mb-3');
$(iframe).attr('target', '_parent');
iframe.onload = function() { // Adjust size of iframe on load
iframe.height = iframe.contentWindow.document.body.scrollHeight + 'px';
loading = false;
};
scrollContainer.appendChild(iframe); // Append it to the document
}
}

Database-Driven Translation Caching Django Template Filter This is a Django template filter designed to cache translations. It uses database models representing the translations and then queries them by text so you can render text in any language on a website, and only translate the text once. I have also included the code I use to translate the text, using NLP Translation from RapidAPI.com, as well as middleware to get the request in a template filter (in order to get the language). This code relies on the browser's language code, as well as a query string, ?lang=, to render the text in the users' languages. I have added comments to describe how the code works. The code begins with some middleware:
# app/middleware.py
from threading import local # Imports
from django.utils.deprecation import MiddlewareMixin
_request = local() # Store the request
class CurrentRequestMiddleware(MiddlewareMixin): # Use a middleware mixin to save the request
def process_request(self, request):
_request.value = request
def get_current_request(): # Return the request
try:
return _request.value
except AttributeError:
return None
# project/settings.py
MIDDLEWARE = [
'blog.middleware.CurrentRequestMiddleware', # The middleware we just made for the request
'django.middleware.locale.LocaleMiddleware' # Middleware to store the language code in the request
]
# app/models.py
from django.db import models
class Translation(models.Model):
id = models.AutoField(primary_key=True)
src = models.CharField(max_length=2, default='en')
lang = models.CharField(max_length=2, default='en')
value = models.TextField(blank=True)
translated = models.TextField(blank=True)
# app/templatetags/app_filters.py
from app.models import Translation # Imports
from app.middleware import get_current_request
from django import template
register = template.Library() # Register the template library
def get_lang(): # Get the language to translate to
request = get_current_request()
lang = request.LANGUAGE_CODE
if(request.GET.get('lang', '') != ''):
lang = request.GET.get('lang', '')
if lang == None:
lang = 'en'
return lang
# Tranlsate a string to any language
def translateval(value, lang, src=None):
src = src if src != None else 'en'
if lang == src:
return value
trans = Translation.objects.filter(value=value,lang=lang,src=src if src != None else 'en') # Get the translation
if trans.count() > 0: # Return it if it exists
return trans.first().translated
else: # Otherwise create it
originalvalue = value
value = value.replace('\n', '
') # Preserve newlines
translation = ''
try:
translation = requests.request("GET", url, headers=headers, params={"text": value, "to": lang, "from": src if src != None else 'en', 'protected_words': '@;
;'}).json()['translated_text'][lang]'protected_words>
except:
translation = value
translation = translation.replace('
', '\n').replace('
','\n').replace('
', '\n') # Newline fix, to preserve newlines
ntrans = Translation.objects.create(value=originalvalue,lang=lang,src=src if src != None else 'en', translated=translation) # Create a new translation
ntrans.save()
return ntrans.translated # Return the translated value
# A template filter to translate from english to any language
@register.filter('etran') # Register the filter to translate
def etran(value):
lang = get_lang() # Get the language
translation = None
if not lang == 'en':
try:
translation = translateval(value, lang, 'en') # Translate using NLP translation
except:
translation = None
if translation != None:
return translation
return value
{{ 'Here is some text. This text will be translated from English to another language'|etran }}
© Uglek, 2022