def __init__(self,
blur_mask_fade=NUDITY_DETECTION_SETTINGS['blur_mask_fade'],
threshold=NUDITY_DETECTION_SETTINGS['threshold']):
self._classifier = NudeClassifier()
self._blur = ImageBlur(PixelBlur(30), blur_mask_fade)
self._threshold = threshold
self._graph = tf.get_default_graph()
def detect(src_path, video):
frame_size = (160, 90)
interval_millis = 1000
classifier = NudeClassifier(settings.NUDE_NET_CLASSIFIER_MODEL_PATH)
video.status = Video.Status.DETECTING
video.save()
src_name = os.path.splitext(os.path.basename(src_path))[0]
output_dir = os.path.join(os.path.dirname(src_path), src_name)
os.makedirs(output_dir)
extract_frames(src_path, output_dir, frame_size, interval_millis)
detected = list()
thresold = 3 * interval_millis
print('start detecting %d files' % (len(os.listdir(output_dir))))
for frame in sorted(os.listdir(output_dir), key=lambda f: frame_order(f)):
order = frame_order(frame)
if order < 0:
continue
framepath = os.path.join(output_dir, frame)
if not os.path.exists(framepath) or os.path.isdir(framepath):
continue
result = classifier.classify(framepath)[framepath]
nudity_prob = result['nude']
if nudity_prob > 0.8:
start_millis = order * interval_millis
end_millis = (order + 1) * interval_millis
if not detected:
detected.append(
DetectedScene(src_video=video,
start_millis=start_millis,
end_millis=end_millis,
cause=DetectedScene.DetectionCause.NUDITY))
else:
latest = detected[-1]
if latest.end_millis + thresold <= start_millis:
detected.append(
DetectedScene(
src_video=video,
start_millis=start_millis,
end_millis=end_millis,
cause=DetectedScene.DetectionCause.NUDITY))
else:
latest.end_millis = end_millis
print('the number of detected scenes is %d' % len(detected))
for scene in detected:
scene.save()
video.status = Video.Status.DETECTED
video.save()
try:
shutil.rmtree(output_dir)
except Exception as e:
print('fail to remove directory', e)
return detected
async def sex_message_check(redis, db):
classifier = NudeClassifier()
while True:
lst = await redis.hgetall('avr', encoding='utf-8')
if not lst == {}:
for i in lst.keys():
path = lst[i]
status = classifier.classify(path)
if status[path]['safe'] < status[path]['unsafe']:
await Message.delete_image(db=db, user=i, image=path)
await asyncio.sleep(10)
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self, identifier=9811198108111121, force_registration=True)
default_guild = {"enabled": False, "channel_id": None}
self.config.register_guild(**default_guild)
# self.detector = NudeDetector()
self.classifier = NudeClassifier()
self.data_path: pathlib.Path = cog_data_path(self)
self.current_processes = 0
class CensorNudity:
def __init__(self,
blur_mask_fade=NUDITY_DETECTION_SETTINGS['blur_mask_fade'],
threshold=NUDITY_DETECTION_SETTINGS['threshold']):
self._classifier = NudeClassifier()
self._blur = ImageBlur(PixelBlur(30), blur_mask_fade)
self._threshold = threshold
self._graph = tf.get_default_graph()
def __call__(self, image: Image) -> Image:
# Create temporary file (nudenet needs image to be saved)
path = Path(str(uuid.uuid4()) + '.jpg')
Image.save(image, path)
with self._graph.as_default():
detected_nudity = self._classifier.classify([path])
# Delete temporary file
path.unlink()
if detected_nudity[path]['unsafe'] > self._threshold:
nudity_boxes = [BoundingBox(0, 0, *image.size)]
blurred_image_np = self._blur.blur(image, nudity_boxes)
return fromarray(blurred_image_np)
else:
return image
def scan_image(image_url):
if image_url is None:
return None
file_name = ''.join(
random.choices(string.ascii_uppercase + string.digits, k=18))
tmp_path = os.path.join(tempfile.gettempdir(), file_name)
with urllib.request.urlopen(image_url) as url:
output = open(tmp_path, "wb")
output.write(url.read())
output.close()
classifier = NudeClassifier()
img_scan_result = classifier.classify(tmp_path)
os.remove(tmp_path)
return img_scan_result[tmp_path]['unsafe']
def check_for_nudity(user_data: dict):
photo_path_list = user_data["message_photo_paths"]
print(
"\nChecking for nudity in message photos. This might take a while depending on the number of photos."
)
classifier = NudeClassifier()
classification = classifier.classify(photo_path_list, 4)
unsafe_photo_paths = []
for photo_path in photo_path_list:
try:
if classification[photo_path]["unsafe"] > 0.95:
print("OYASHII: ", photo_path)
unsafe_photo_paths.append(photo_path)
except KeyError:
print("A photo is mysteriously missing.")
nbr_of_unsafe_photos = len(unsafe_photo_paths)
output_html = unsafe_photo_carousel_html_generator(unsafe_photo_paths)
user_data["unsafe_html"] = output_html
user_data["nbr_of_unsafe_photos"] = nbr_of_unsafe_photos
user_data["unsafe_photo_paths"] = unsafe_photo_paths
return user_data
def run(self, path):
""" Classify an image using NudeNet."""
# if there is not a classifier, create it. This takes a long time, so create only one classifier (global variable)
global classifier
if classifier is None:
self.logger().debug('Creating classifier from model=%s',
self.myconfig('model'))
modelfile = self.myconfig('model')
classifier = NudeClassifier(modelfile)
threshold = float(self.myconfig('threshold'))
self.logger().debug('Classifying path=%s', path)
# classify path
if os.path.isabs(path):
abspath = path
relpath = relative_path(path, self.myconfig('casedir'))
else:
abspath = os.path.join(self.myconfig('casedir'), path)
relpath = path
result = dict(path=relpath,
aiclassify=dict(classifier='NudeNet'),
preview=relpath)
try:
# we must convert the results, since they are returned as numpy object
classification = classifier.classify(abspath)[abspath]
result['aiclassify']['results'] = dict(
safe=float(classification['safe']),
unsafe=float(classification['unsafe']))
result['aiclassify']['is_nude'] = result['aiclassify']['results'][
'unsafe'] > threshold
except Exception as exc:
self.logger().warning('Cannot process path=%s %s', path, exc)
result['aiclassify']['results'] = dict(safe=None, unsafe=None)
result['aiclassify']['is_nude'] = None
yield result
import pydload
import uuid
import json
import time
import requests
import logging
from flask import Flask, request
from flask_cors import CORS, cross_origin
from nudenet import NudeClassifier
classifier = NudeClassifier("models/classifier_model")
app = Flask(__name__)
cors = CORS(app)
# @app.route('/hello')
# @cross_origin()
# def hello():
# return "Hello World!"
@app.route('/nudenet', methods=['GET', 'POST'])
def nudenet_classifier_from_url():
if request.method == 'GET':
url = request.args.get('url')
elif request.method == 'POST':
url = request.json['url']
try:
path = str(uuid.uuid4())
dload_status = pydload.dload(url, path)
import os
import cv2
from nudenet import NudeClassifier, NudeDetector
video_path = 'p**n.mp4'
classifier = NudeClassifier()
dic = classifier.classify_video(video_path, batch_size=4)
# dic = classifier.classify('example.jpg')
# detector = NudeDetector()
# dic = detector.detect('example.jpg')
print(dic)
video = cv2.VideoCapture(video_path)
print(video.isOpened())
fps = video.get(cv2.CAP_PROP_FPS)
length = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
print("fps:", fps, "length", length)
# print(os.getcwd())
Options:
--tolerance=<tolerance> Number of video frames to tolerate before issuing a warning.[default=4]
--debug Prints the inference logs.
"""
from collections import deque
import cv2
from docopt import docopt
from nudenet import NudeClassifier
from secureconnect import inference
from secureconnect.exceptions import UnsafeEnvironment
# load the model once for every inference.
mdl = NudeClassifier()
def is_safety_buffer_critical(queue, tolerance):
"""
Exit program with an error.
If all items in the queue are True. This means we
have exhausted our tolerance for nsfw content and it
is unsafe for continuing to use video-source.
"""
unsafe_flags = [item for item in list(queue) if item]
if unsafe_flags == tolerance:
raise UnsafeEnvironment
import requests
import base64
import random
import json
from nudenet import NudeClassifier
import os
from datetime import datetime
from termcolor import colored
nsfw_classifier = NudeClassifier()
animals = ["cat", "dog", "wolf", "otter", "panda"]
muted_people = []
cat_images_api = "https://api.thecatapi.com/v1/images/search"
dog_facts_api = "https://dog-facts-api.herokuapp.com/api/v1/resources/dogs?number=1"
trivia_api = "https://opentdb.com/api.php?amount=1&category=9&difficulty=easy&type=boolean&encode=base64"
yoda_api = "http://yoda-api.appspot.com/api/v1/yodish?text="
joke_api = "https://official-joke-api.appspot.com/random_joke"
nasa_image_search_api = "https://images-api.nasa.gov/search?"
def get_json_data(url):
result = requests.get(url)
result_json = result.json()
return result_json
def get_cat_image_url():
json_object = get_json_data(cat_images_api)
image_object = json_object[0]
image_url = image_object["url"]
def run(self, path):
""" Classify a video using NudeNet."""
if os.path.isabs(path):
relpath = relative_path(path, self.myconfig('casedir'))
abspath = path
else:
relpath = path
abspath = os.path.join(self.myconfig('casedir'), path)
self.check_params(abspath, check_path=True, check_path_exists=True)
# if there is not a classifier, create it. This takes a long time, so create only one classifier (global variable)
global classifier
if classifier is None:
self.logger().debug('Creating classifier from model=%s',
self.myconfig('model'))
modelfile = self.myconfig('model')
classifier = NudeClassifier(modelfile)
if os.path.isabs(path):
relpath = relative_path(path, self.myconfig('casedir'))
else:
relpath = path
previews = list(self.from_module.run(path))
# if the previews could be created, the video cannot be parsed: return None
if not previews or len(previews) == 0:
return [
dict(path=relpath,
aiclassify=dict(classifier='NudeNet',
results=dict(safe=None, unsafe=None),
is_nude=None))
]
# else, the video was parsed correctly: test each one of the previews.
max_unsafe = 0
min_safe = 0
num_is_nude = 0
preview_path = None
for preview_image in previews[0]['preview']:
# classify preview_image
result = list(super().run(preview_image))[0]
if result['aiclassify']['results']['unsafe'] is not None and result[
'aiclassify']['results']['unsafe'] > max_unsafe:
max_unsafe = result['aiclassify']['results']['unsafe']
min_safe = result['aiclassify']['results']['safe']
if result['aiclassify']['is_nude']:
num_is_nude += 1
# if an image is unsafe: set the preview to this image
preview_path = relative_path(preview_image,
self.myconfig('casedir'))
final_result = dict(classifier='NudeNet',
results=dict(safe=min_safe, unsafe=max_unsafe),
is_nude=None)
if len(previews[0]['preview']) > 0:
final_result['is_nude'] = (
1.0 * num_is_nude / len(previews[0]['preview']) > float(
self.myconfig('threshold_preview')))
if preview_path is None:
# if no preview path is already set, get the image in the middle
preview_path = previews[0]['preview'][int(
len(previews[0]['preview']) / 2)]
return [
dict(path=relpath, aiclassify=final_result, preview=preview_path)
]
# https://github.com/notAI-tech/NudeNet
# https://github.com/ndaysinaiK/nude-test
# pip install --upgrade nudenet
import time
import datetime
start = time.time()
# Import module
from nudenet import NudeClassifier
# initialize classifier (downloads the checkpoint file automatically the first time)
classifier = NudeClassifier()
from os import listdir
from os.path import isfile, join
from pathlib import Path
from shutil import copyfile
mypath = '../img/'
safePath = mypath + 'safe/'
unsafePath = mypath + 'unsafe/'
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
Path(safePath).mkdir(parents=True, exist_ok=True)
Path(unsafePath).mkdir(parents=True, exist_ok=True)
for f in listdir(mypath):
if isfile(join(mypath, f)):
filename = mypath + f
import pyautogui
from nudenet import NudeClassifier
import time
classifier = NudeClassifier('models/classifier_model')
def main():
# while True:
# for i in range (10):
# print("taking screenshot")
# myScreenshot = pyautogui.screenshot()
# myScreenshot.save('imgs/test.png')
# print("starting classification")
# classifier = NudeClassifier('models/classifier_model')
# print(classifier.classify('imgs/test.png'))
filepath = 'imgs/test.png'
print("starting classification")
classified_dict = classifier.classify('imgs/test.png')
print(classified_dict)
print(classified_dict[filepath]['unsafe'])
if __name__ == "__main__":
main()
def __init__(self, mode, specific_formats=None, specific_folder=None):
self.mode = mode
self.lst_of = {}
self.doc_ext = []
self.img_ext = []
self.vid_ext = []
self.sound_ext = []
self.zip_ext = []
self.code_ext = []
self.media_ext = []
self.data_ext = []
self.app_ext = []
self.font_ext = []
self.sys_ext = []
self.flags = []
self.specifics = []
self.all_files = {}
self.errors = []
self.file_structure = {}
self.load_ext()
self.now = datetime.now()
self.dt_string = self.now.strftime("%d-%m-%Y %Hh%M")
self.nude_classifier = NudeClassifier()
self.nude_detector = NudeDetector()
self.s = sched.scheduler(time.time, time.sleep)
self.number_of_files = 0
self.time_taken = 0
self.prev_dir = None
self.curr_dir = None
self.faces = None
self.points = None
self.walked_dir = "checked.dir"
self.all_walked = []
self.load_walked()
self.available_dirs = []
self.non_available_dirs = []
self.attach = ":/"
self.let_dir = [
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
"N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
]
self.runt = threading.Thread(target=self.find_all_dirs)
self.runt.start()
self.master_ext = [
self.doc_ext, self.img_ext, self.vid_ext, self.sound_ext,
self.zip_ext, self.code_ext, self.media_ext, self.data_ext,
self.app_ext, self.font_ext, self.sys_ext, self.flags
]
self.type_s = [
"Documents", "Images", "Videos", "Sounds", "Compressed_Files",
"Programming_Files", "Discs_Media", "Databases", "Applications",
"Fonts", "System_Files", "Infected"
]
self.face_detection = fc.Detection()
self.face_recognition = fc.Recognition()
self.face_verification = fc.Verification()
if specific_formats is not None and specific_folder is not None:
self.specifics = self.specifics + specific_formats
self.master_ext.append(self.specifics)
self.type_s.append(specific_folder)
bot_mode = config['bot']['mode']
debug = config.getboolean('bot', 'debug')
token = config['bot']['token']
clientid = config['bot']['clientid']
prefix = str(config['bot']['prefix'])
botperms = config['bot']['botperms']
# policy
denythreshold = config.getfloat('policy', 'denythreshold')
accepted_formats = config['policy']['acceptedfiles'].split(',')
allowtie = config.getboolean('policy', 'allow_ties')
bot = commands.Bot(command_prefix=prefix)
# nude detector is not used unless in debug, so you can see why some images are deemed nsfw
detector = NudeDetector()
classifier = NudeClassifier()
# cog loading
@bot.event
async def on_ready():
invlink = f"https://discord.com/oauth2/authorize?client_id={clientid}&permissions={botperms}&scope=bot"
print(f"lewd stopper is ready, invite me at link {invlink}")
if debug:
print(
"==== WARNING: DEBUG MODE IS ON! NO MESSAGES WILL BE DELETED.====\n==== FOR THIS BOT TO MODERATE PROPERLY, "
"TURN OFF DEBUG IN CONFIG.INI ====")
# this function will be ran async by the executor
def get_classification(image_loc):
from nudenet import NudeClassifier
m = NudeClassifier()
def predictor(x, batch_size=2, extras=[]):
preds = m.classify(x, batch_size=batch_size)
return [preds.get(_) for _ in x]
from nudenet import NudeClassifier
import os
files = os.listdir('Valid')
if not os.path.exists('Valid/Pron'):
os.makedirs('Valid/Pron')
if not os.path.exists('Valid/Error'):
os.makedirs('Valid/Error')
files.remove('Pron')
files.remove('Error')
classifier = NudeClassifier()
for i in files:
try:
data = classifier.classify('Valid/' + i)[i]['unsafe']
if data > 0.7:
print(i + ' is OK')
os.rename('Valid/' + i, 'Valid/Pron/' + i)
else:
os.rename('Valid/' + i, 'Valid/Error/' + i)
except:
continue
from nudenet import NudeClassifier import sys classifier = NudeClassifier() image_path = sys.argv[1] result = classifier.classify(image_path) print(0 if result[image_path]['safe'] > result[image_path]['unsafe'] else 1)
class sorter():
def __init__(self, mode, specific_formats=None, specific_folder=None):
self.mode = mode
self.lst_of = {}
self.doc_ext = []
self.img_ext = []
self.vid_ext = []
self.sound_ext = []
self.zip_ext = []
self.code_ext = []
self.media_ext = []
self.data_ext = []
self.app_ext = []
self.font_ext = []
self.sys_ext = []
self.flags = []
self.specifics = []
self.all_files = {}
self.errors = []
self.file_structure = {}
self.load_ext()
self.now = datetime.now()
self.dt_string = self.now.strftime("%d-%m-%Y %Hh%M")
self.nude_classifier = NudeClassifier()
self.nude_detector = NudeDetector()
self.s = sched.scheduler(time.time, time.sleep)
self.number_of_files = 0
self.time_taken = 0
self.prev_dir = None
self.curr_dir = None
self.faces = None
self.points = None
self.walked_dir = "checked.dir"
self.all_walked = []
self.load_walked()
self.available_dirs = []
self.non_available_dirs = []
self.attach = ":/"
self.let_dir = [
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
"N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
]
self.runt = threading.Thread(target=self.find_all_dirs)
self.runt.start()
self.master_ext = [
self.doc_ext, self.img_ext, self.vid_ext, self.sound_ext,
self.zip_ext, self.code_ext, self.media_ext, self.data_ext,
self.app_ext, self.font_ext, self.sys_ext, self.flags
]
self.type_s = [
"Documents", "Images", "Videos", "Sounds", "Compressed_Files",
"Programming_Files", "Discs_Media", "Databases", "Applications",
"Fonts", "System_Files", "Infected"
]
self.face_detection = fc.Detection()
self.face_recognition = fc.Recognition()
self.face_verification = fc.Verification()
if specific_formats is not None and specific_folder is not None:
self.specifics = self.specifics + specific_formats
self.master_ext.append(self.specifics)
self.type_s.append(specific_folder)
def get_mode(self):
return self.__mode
def get_lst_of(self):
return self.__lst_of
def get_doc_ext(self):
return self.__doc_ext
def get_img_ext(self):
return self.__img_ext
def get_vid_ext(self):
return self.__vid_ext
def get_sound_ext(self):
return self.__sound_ext
def get_zip_ext(self):
return self.__zip_ext
def get_code_ext(self):
return self.__code_ext
def get_media_ext(self):
return self.__media_ext
def get_data_ext(self):
return self.__data_ext
def get_app_ext(self):
return self.__app_ext
def get_font_ext(self):
return self.__font_ext
def get_sys_ext(self):
return self.__sys_ext
def get_flags(self):
return self.__flags
def get_specifics(self):
return self.__specifics
def get_all_files(self):
return self.__all_files
def get_errors(self):
return self.__errors
def get_file_structure(self):
return self.__file_structure
def get_now(self):
return self.__now
def get_dt_string(self):
return self.__dt_string
def get_nude_classifier(self):
return self.__nude_classifier
def get_number_of_files(self):
return self.__number_of_files
def get_time_taken(self):
return self.__time_taken
def get_prev_dir(self):
return self.__prev_dir
def get_curr_dir(self):
return self.__curr_dir
def get_master_ext(self):
return self.__master_ext
def get_type_s(self):
return self.__type_s
def set_mode(self, value):
self.__mode = value
def set_lst_of(self, value):
self.__lst_of = value
def set_doc_ext(self, value):
self.__doc_ext = value
def set_img_ext(self, value):
self.__img_ext = value
def set_vid_ext(self, value):
self.__vid_ext = value
def set_sound_ext(self, value):
self.__sound_ext = value
def set_zip_ext(self, value):
self.__zip_ext = value
def set_code_ext(self, value):
self.__code_ext = value
def set_media_ext(self, value):
self.__media_ext = value
def set_data_ext(self, value):
self.__data_ext = value
def set_app_ext(self, value):
self.__app_ext = value
def set_font_ext(self, value):
self.__font_ext = value
def set_sys_ext(self, value):
self.__sys_ext = value
def set_flags(self, value):
self.__flags = value
def set_specifics(self, value):
self.__specifics = value
def set_all_files(self, value):
self.__all_files = value
def set_errors(self, value):
self.__errors = value
def set_file_structure(self, value):
self.__file_structure = value
def set_now(self, value):
self.__now = value
def set_dt_string(self, value):
self.__dt_string = value
def set_nude_classifier(self, value):
self.__nude_classifier = value
def set_number_of_files(self, value):
self.__number_of_files = value
def set_time_taken(self, value):
self.__time_taken = value
def set_prev_dir(self, value):
self.__prev_dir = value
def set_curr_dir(self, value):
self.__curr_dir = value
def set_master_ext(self, value):
self.__master_ext = value
def set_type_s(self, value):
self.__type_s = value
def del_mode(self):
del self.__mode
def del_lst_of(self):
del self.__lst_of
def del_doc_ext(self):
del self.__doc_ext
def del_img_ext(self):
del self.__img_ext
def del_vid_ext(self):
del self.__vid_ext
def del_sound_ext(self):
del self.__sound_ext
def del_zip_ext(self):
del self.__zip_ext
def del_code_ext(self):
del self.__code_ext
def del_media_ext(self):
del self.__media_ext
def del_data_ext(self):
del self.__data_ext
def del_app_ext(self):
del self.__app_ext
def del_font_ext(self):
del self.__font_ext
def del_sys_ext(self):
del self.__sys_ext
def del_flags(self):
del self.__flags
def del_specifics(self):
del self.__specifics
def del_all_files(self):
del self.__all_files
def del_errors(self):
del self.__errors
def del_file_structure(self):
del self.__file_structure
def del_now(self):
del self.__now
def del_dt_string(self):
del self.__dt_string
def del_nude_classifier(self):
del self.__nude_classifier
def del_number_of_files(self):
del self.__number_of_files
def del_time_taken(self):
del self.__time_taken
def del_prev_dir(self):
del self.__prev_dir
def del_curr_dir(self):
del self.__curr_dir
def del_master_ext(self):
del self.__master_ext
def del_type_s(self):
del self.__type_s
def run_t(self):
self.s.enter(60, 1, self.find_all_dirs, (self.s, ))
self.s.run()
def find_all_dirs(self):
for i in range(len(self.let_dir)):
dr = self.let_dir[i] + self.attach
if os.path.isdir(dr):
self.available_dirs.append(dr)
else:
self.non_available_dirs.append(dr)
#self.s.enter(60, 1, self.find_all_dirs, (self.s,))
def load_ext(self):
extensions_path = "C:/Users/GabhaDi/eclipse-workspace2/project sortMyFiles/src/extensions/"
name = [
"application", "code", "data", "document", "flags", "font",
"image", "media", "sound", "system", "video", "zip"
]
#full_path = os.path.abspath(extensions_path)
i = 0
print("The full to your extensions is ", extensions_path)
if os.path.isdir(extensions_path) is True:
print("loading all extensions...")
list_files = os.listdir(extensions_path)
for file in list_files:
if "document" in file:
with open(extensions_path + file) as f:
for line in f:
self.doc_ext.append(line.rstrip("\n"))
print("Successfully loaded document exts, size : ",
len(self.doc_ext), self.doc_ext)
if "image" in file:
with open(extensions_path + file) as f:
for line in f:
self.img_ext.append(line.rstrip("\n"))
print("Successfully loaded image exts, size : ",
len(self.img_ext), self.img_ext)
if "video" in file:
with open(extensions_path + file) as f:
for line in f:
self.vid_ext.append(line.rstrip("\n"))
print("Successfully loaded video exts, size : ",
len(self.vid_ext), self.vid_ext)
if "application" in file:
with open(extensions_path + file) as f:
for line in f:
self.app_ext.append(line.rstrip("\n"))
print("Successfully loaded app exts, size : ",
len(self.app_ext), self.app_ext)
if "code" in file:
with open(extensions_path + file) as f:
for line in f:
self.code_ext.append(line.rstrip("\n"))
print("Successfully loaded source code exts, size : ",
len(self.code_ext), self.code_ext)
if "data" in file:
with open(extensions_path + file) as f:
for line in f:
self.data_ext.append(line.rstrip("\n"))
print("Successfully loaded database exts, size : ",
len(self.data_ext), self.data_ext)
if "flags" in file:
with open(extensions_path + file) as f:
for line in f:
self.flags.append(line.rstrip("\n"))
print(
"Successfully loaded dangerous and malicious exts, size : ",
len(self.flags), self.flags)
if "font" in file:
with open(extensions_path + file) as f:
for line in f:
self.font_ext.append(line.rstrip("\n"))
print("Successfully loaded font exts, size : ",
len(self.font_ext), self.font_ext)
if "media" in file:
with open(extensions_path + file) as f:
for line in f:
self.media_ext.append(line.rstrip("\n"))
print("Successfully loaded media exts, size : ",
len(self.media_ext), self.media_ext)
if "sound" in file:
with open(extensions_path + file) as f:
for line in f:
self.sound_ext.append(line.rstrip("\n"))
print("Successfully loaded sound and audio exts, size : ",
len(self.sound_ext), self.sound_ext)
if "system" in file:
with open(extensions_path + file) as f:
for line in f:
self.sys_ext.append(line.rstrip("\n"))
print("Successfully loaded system exts, size : ",
len(self.sys_ext), self.sys_ext)
if "zip" in file:
with open(extensions_path + file) as f:
for line in f:
self.zip_ext.append(line.rstrip("\n"))
print(
"Successfully loaded archive and compressions exts, size : ",
len(self.zip_ext), self.zip_ext)
print("Successfully loaded all extensions...")
def load_walked(self):
if os.path.isfile(self.walked_dir):
with open(self.walked_dir) as f:
for line in f:
self.all_walked.append(line.rstrip("\n"))
else:
print("File doesnt't exist.")
def load_session(self, dir):
if len(self.all_files) != 0:
self.all_files.clear()
all_files = []
pc = []
if os.path.isdir(dir) == True:
dir_list = os.listdir(dir)
session = "session.sess"
session_cp = "session_cp.sess"
if (session in dir_list) is True and (session_cp
in dir_list) is True:
with open(session) as f:
for line in f:
all_files.append(
[int(n) for n in line.strip().split(',')])
for pair in all_files:
try:
self.all_files[pair[0]] = pair[1]
except IndexError:
print(
"A line in the file doesn't have enough entries"
)
with open(session_cp) as fn:
for line in fn:
pc.append(
[int(n) for n in line.strip().split(',')])
for pair in pc:
try:
self.prev_dir = pair[0]
self.curr_dir = pair[1]
except IndexError:
print(
"A line in the file doesn't have enough entries"
)
print(
f"Successfully loaded sessions for from files {session} and {session_cp} from directory {dir}"
)
return 1
else:
print(
f"Something went wrong...i couldnt find the files {session} and {session_cp} in dir"
)
return -1
else:
print(
f"Something went wrong...invalid directory provided ERROR : {dir} doesn't exist"
)
return -1
def add_dir(self, new_dir):
if (os.path.exists(self.walked_dir) == False):
f = open(self.walked_dir, "w+")
else:
f = open(self.walked_dir, "a+")
_checked = open(self.walked_dir, 'r').readlines()
_checked = [i.strip() for i in _checked]
if (new_dir in _checked) is True:
print("Skipping ", new_dir, " it has been added.")
elif new_dir not in _checked:
f.write(new_dir + "\n")
else:
f.write(new_dir + "\n")
f.close()
def files(self, directory):
total_files = 0
total_directories = 0
if os.path.isdir(directory) == True:
dir_list = os.listdir(directory)
print("Listing dir")
print(dir_list)
print("Total size : ", len(dir_list))
for file in dir_list:
print(file)
if os.path.isfile(os.path.abspath(file) == True):
i = 0
for extensions in self.master_ext:
for ext in extensions:
if ext in file:
self.lst_of[file] = self.type_s[i]
if os.path.isdir(os.path.abspath(file)) == True:
#new_dir_list = os.listdir(file)
print()
print()
print(os.path.dirname(file))
self.files(os.path.abspath(file))
i += 1
def copy_(self, new_directory):
if not os.path.exists(new_directory):
os.mkdir(new_directory)
for key, value in self.lst_of.items():
#new_directory = new_directory + value + "/"
try:
print(key, new_directory + "/" + value + "/")
if not os.path.exists(new_directory + "/" + value + "/"):
os.mkdir(new_directory + "/" + value + "/")
copy(key, new_directory + "/" + value + "/")
else:
copy(key, new_directory + "/" + value + "/")
except Exception as e:
print(e)
continue
else:
for key, value in self.lst_of.items():
try:
#new_directory = new_directory + value + "/"
print(key, new_directory + "/" + value + "/")
if not os.path.exists(new_directory + "/" + value + "/"):
os.mkdir(new_directory + "/" + value + "/")
copy(key, new_directory + "/" + value + "/")
else:
copy(key, new_directory + "/" + value + "/")
except Exception as e:
print(e)
continue
def move_(self, new_directory):
if not os.path.exists(new_directory):
os.mkdir(new_directory)
for key, value in self.lst_of.items():
#new_directory = new_directory + value + "/"
try:
print(key, new_directory + "/" + value + "/")
if not os.path.exists(new_directory + "/" + value + "/"):
os.mkdir(new_directory + "/" + value + "/")
move(key, new_directory + "/" + value + "/")
else:
move(key, new_directory + "/" + value + "/")
except Exception as e:
print(e)
continue
else:
for key, value in self.lst_of.items():
try:
#new_directory = new_directory + value + "/"
print(key, new_directory + "/" + value + "/")
if not os.path.exists(new_directory + "/" + value + "/"):
os.mkdir(new_directory + "/" + value + "/")
move(key, new_directory + "/" + value + "/")
else:
move(key, new_directory + "/" + value + "/")
except Exception as e:
print(e)
continue
def rollback(self, files, prev_dir, curr_dir):
if len(files) < 0:
print(
"Please provide the files that you want to undo the process.")
return
if type(files) is not dict:
print("files should be list, but ", type(files),
" was provided instead.")
return
if not os.path.isdir(prev_dir):
print(
"The provided previous directory is not a directory or doesn't exist, please check ",
prev_dir)
return
if not os.path.isdir(curr_dir):
print(
"The provide current directory is not a directory or doesn't exist, please check ",
curr_dir)
return
print("Rollback Operation started : from - ", curr_dir, " to - ",
prev_dir)
dir_walk = os.walk(curr_dir)
new_files = {}
for (root, dirs, files_) in dir_walk:
for f in files_:
for file, full_path in files.items():
if f == file:
new_files[os.path.join(root, f)] = full_path
print(new_files)
for each_file, fullpath in new_files.items():
try:
print("FROM -- [", each_file, "] TO -- [", fullpath,
"] success")
move(each_file, fullpath)
except Exception as e:
print(e)
continue
def display(self, dic):
for key, value in dic.items():
try:
print(key, value)
except Exception as e:
print(e)
continue
#Todo rollback code here
#Main function is to reverse any sorting done by the program
# 1. Get all the files and their paths
# 2. Move them from their curr directory to their previous directories
# 3. Verify and check if the operation was successful
# 4. Save the progress for later use
def check_for_faces(self, directory):
(self.im_width, self.im_height) = (160, 160)
face_pic = 0
file_sess = "face.check"
print("Checking for faces...", directory)
directory = directory + "/images"
face_ = directory + "/" + "faces"
file_s = directory + "/" + file_sess
if os.path.exists(file_s) is False:
f = open(file_s, 'w+')
else:
f = open(file_s, 'a+')
previous_session = open(file_s, 'r').readlines()
previous_session = [i.strip() for i in previous_session]
print(file_s, len(previous_session), previous_session)
if os.path.isdir(face_) is False:
os.mkdir(face_)
if os.path.isdir(directory) is True:
images = os.listdir(directory)
for each_pic in images:
self.pin = (sorted([
int(n[:n.find(".")])
for n in os.listdir(face_) if n[0] != "."
] + [0])[-1] + 1)
if (each_pic in previous_session) is True:
print("Skipping file", each_pic, "already scanned")
continue
elif each_pic not in previous_session:
f.write(each_pic + "\n")
try:
image = cv2.imread(
os.path.abspath(directory + "/" + each_pic), 1)
normal = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
normal = cv2.cvtColor(normal, cv2.COLOR_RGB2BGR)
if self.face_recognition.detection(image) is None:
faces = None
if self.face_recognition.detection(image) is not None:
faces, points = self.face_recognition.detection(
image)
if faces is not None:
for face in faces:
face_bb = face.bounding_box.astype(int)
yourface = normal[
max(0, face_bb[1]
):min(face_bb[3], normal.shape[0] - 1),
max(0, face_bb[0]
):min(face_bb[2], normal.shape[1] -
1), ]
for i in range(points.shape[1]):
pts = points[:, i].astype(np.int32)
for j in range(pts.size // 2):
pt = (pts[j], pts[5 + j])
cv2.circle(
image,
center=pt,
radius=1,
color=(255, 0, 0),
thickness=2,
)
face_resize = cv2.resize(
yourface, (self.im_width, self.im_height))
cv2.rectangle(
image,
(face_bb[0], face_bb[1]),
(face_bb[2], face_bb[3]),
(22, 20, 60),
1,
)
cv2.imwrite("%s/%s.png" % (face_, self.pin),
face_resize)
print(
f"Face detected in image {each_pic} now creating face in {face_+'/'+str(self.pin)}.png"
)
face_pic += 1
cv2.destroyAllWindows()
except:
continue
else:
f.write(each_pic + "\n")
print(f"Process done. Created {face_pic} face files to {face_+'/'}")
def check_for_porn(self, directory):
profane_pic = 0
file_sess = "profanity.check"
print("Checking for nudity and pornographic material...", directory)
directory = directory + "/images"
profanity = directory + "/" + "Profanity"
file_s = directory + "/" + file_sess
if os.path.exists(file_s) is False:
f = open(file_s, 'w+')
else:
f = open(file_s, 'a+')
previous_session = open(file_s, 'r').readlines()
previous_session = [i.strip() for i in previous_session]
print(file_s, len(previous_session), previous_session)
if os.path.isdir(profanity) is False:
os.mkdir(profanity)
if os.path.isdir(directory) is True:
images = os.listdir(directory)
for each_pic in images:
if (each_pic in previous_session) is True:
print("Skipping file", each_pic, "already scanned")
continue
elif each_pic not in previous_session:
f.write(each_pic + "\n")
preds = self.nude_classifier.classify(
os.path.abspath(directory + "/" + each_pic))
#print(preds, type(preds))
for (path, dicti) in preds.items():
for lvl, score in dicti.items():
if lvl is 'unsafe' and score >= 0.9:
print(
f"Profanity detected ",
f"Image ({each_pic}) MOVING to {profanity}..."
)
move(path, os.path.abspath(profanity))
profane_pic += 1
elif lvl is 'unsafe' and score >= .6 and score < 0.9:
print(
f"Indecency detected ",
f"Am not sure about Image ({each_pic}) should i move it to {profanity}..."
)
image = cv2.imread(path, 1)
width = 320
height = 320
dim = (width, height)
try:
resized_img = cv2.resize(
image, dim, cv2.INTER_AREA)
cv2.imshow("SUGGESTION", resized_img)
except:
print(e)
continue
print(
f" Move {path} Press(y) to move or n to continue?"
)
k = cv2.waitKey(0)
if (k == ord('y')):
move(path, os.path.abspath(profanity))
profane_pic += 1
cv2.destroyAllWindows()
print(
f"Suggestion moved {path} to {profanity}"
)
else:
cv2.destroyAllWindows()
continue
#print(preds)
#f.append(each_pic+"\n")
else:
f.write(each_pic + "\n")
print(
f"Process done. Moved {profane_pic} profane files to {profanity}")
def save_session(self, fls, prev, curr):
#if(type(self.files) is not dict):
# print(f"Must be dictionary not {type(files)}")
# return
if (len(fls) == 0):
print("print data not provided its empty")
return
if (os.path.isdir(prev) == False):
print("Please provide a valid directory ERROR : ", prev)
if (os.path.isdir(curr) == False):
print("Please provide a valid directory ERROR : ", curr)
filename = "session.sess"
full_filename = str(os.path.abspath(os.path.join(curr, filename)))
#full_dr = new_directory + "/" + filename
print(full_filename, self.dt_string, "string : ", fls)
fn = "session_cp.sess"
full_fn = str(os.path.abspath(os.path.join(curr, fn)))
if os.path.exists(full_filename) is False:
f = open(full_filename, 'w+', encoding="utf-8")
fp = open(full_fn, 'w+', encoding="utf-8")
fp.write(prev + "," + curr + "\n")
else:
f = open(full_filename, 'a+', encoding="utf-8")
fp = open(full_fn, 'w+', encoding="utf-8")
fp.write(prev + "," + curr + "\n")
_checked_ = open(full_filename, 'r').readlines()
_checked_ = [i.strip() for i in _checked_]
for file, dr in self.all_files.items():
x = file + "," + dr
if (x in _checked_):
print("Skipping ", x, "it has been added")
continue
elif x not in _checked_:
f.write(x + "\n")
else:
f.write(x + "\n")
f.close()
fp.close()
print("Successfully Saved session at ", self.dt_string)
def sort_dir(self, directory):
self.prev_dir = directory
#given a dir, check if its a dir or not
print("Starting sorting operation...", directory)
if os.path.isdir(directory) == True:
#print("Listing dir")
dir_list = os.walk(directory)
#print(dir_list)
#print("Total size : ", len(dir_list))
for (root, dirs, files) in dir_list:
self.number_of_files = len(files)
#print(files)
i = 0
print("files LEN ", self.number_of_files, " DIRS LEN ",
len(dirs), "root ", root, "dirs ", dirs, "files ", files)
for direct in dirs:
full_dir = os.path.join(root, direct)
if os.path.isdir(full_dir) is True:
full_dir_files = os.listdir(full_dir)
self.file_structure[full_dir] = full_dir_files
for extensions in self.master_ext:
for ext in extensions:
for file in files:
try:
EXT_ = file.split(".")[1]
EXT_ = "." + EXT_
if EXT_ == ext:
#print("ROOT ", root, "DIRECTORIES : ", dirs, "FILES ", files)
self.lst_of[os.path.join(
root, file)] = self.type_s[i]
print("TYPE : ", self.type_s[i],
"FILE EXT FOUND : ", ext,
"FILE NAME : ",
os.path.join(root, file), "ITER : ",
i, EXT_)
#self.all_files.append(file)
self.all_files[file] = os.path.join(
root, file)
except:
print("ERROR WITH FILE : ", file)
continue
i += 1
new_directory = input("Please enter name of new directory...")
print("Available dirs please choose which dir to ", self.mode,
" to?")
self.runt.join()
for i in range(len(self.available_dirs)):
print(i, self.available_dirs[i])
choice = input("Please choose directory?")
while True:
if int(choice) < 0 or int(choice) > len(self.available_dirs):
print("Invalid choice!!!, Please choose again.")
choice = input("Please choose directory?")
continue
else:
break
new_directory = self.available_dirs[int(
choice)] + new_directory + "_" + os.path.basename(directory)
self.curr_dir = new_directory
print(new_directory)
print(self.lst_of)
self.display(self.lst_of)
if self.mode == 'move':
self.move_(new_directory)
else:
self.copy_(new_directory)
self.save_session(self.all_files, self.prev_dir, self.curr_dir)
self.add_dir(new_directory)
print("All files : ", self.all_files, " Previous Directory : ",
self.prev_dir, " Current Directory : ", self.curr_dir)
choice = input(
f"Operation {self.mode} is done, Are you sure you want to continue or Rollback the process Y - Yes(Rollback) / N - No(Continue)?"
)
choice = choice.lower()
if "y" in choice or choice is "y" or choice is "yes" or "yes" in choice:
#prev_dir = input("Please enter the previous directory where the files where located before operation")
#curr_dir = input("Please enter the current directory where the files where are located now")
self.rollback(self.all_files, self.prev_dir, self.curr_dir)
print(
"Rollback operation successfully files where placed back to their original places."
)
threading.Thread(target=self.check_for_porn(new_directory)).start()
else:
print("Directory doesn't exist : ", directory,
"Please enter a valid directory!")
path = input(
"Please enter the directory or folder or file path you want to sort?"
)
srt.sort_dir(rf"{path}")
mode = property(get_mode, set_mode, del_mode, "mode's docstring")
lst_of = property(get_lst_of, set_lst_of, del_lst_of, "lst_of's docstring")
doc_ext = property(get_doc_ext, set_doc_ext, del_doc_ext,
"doc_ext's docstring")
img_ext = property(get_img_ext, set_img_ext, del_img_ext,
"img_ext's docstring")
vid_ext = property(get_vid_ext, set_vid_ext, del_vid_ext,
"vid_ext's docstring")
sound_ext = property(get_sound_ext, set_sound_ext, del_sound_ext,
"sound_ext's docstring")
zip_ext = property(get_zip_ext, set_zip_ext, del_zip_ext,
"zip_ext's docstring")
code_ext = property(get_code_ext, set_code_ext, del_code_ext,
"code_ext's docstring")
media_ext = property(get_media_ext, set_media_ext, del_media_ext,
"media_ext's docstring")
data_ext = property(get_data_ext, set_data_ext, del_data_ext,
"data_ext's docstring")
app_ext = property(get_app_ext, set_app_ext, del_app_ext,
"app_ext's docstring")
font_ext = property(get_font_ext, set_font_ext, del_font_ext,
"font_ext's docstring")
sys_ext = property(get_sys_ext, set_sys_ext, del_sys_ext,
"sys_ext's docstring")
flags = property(get_flags, set_flags, del_flags, "flags's docstring")
specifics = property(get_specifics, set_specifics, del_specifics,
"specifics's docstring")
all_files = property(get_all_files, set_all_files, del_all_files,
"all_files's docstring")
errors = property(get_errors, set_errors, del_errors, "errors's docstring")
file_structure = property(get_file_structure, set_file_structure,
del_file_structure, "file_structure's docstring")
now = property(get_now, set_now, del_now, "now's docstring")
dt_string = property(get_dt_string, set_dt_string, del_dt_string,
"dt_string's docstring")
nude_classifier = property(get_nude_classifier, set_nude_classifier,
del_nude_classifier,
"nude_classifier's docstring")
number_of_files = property(get_number_of_files, set_number_of_files,
del_number_of_files,
"number_of_files's docstring")
time_taken = property(get_time_taken, set_time_taken, del_time_taken,
"time_taken's docstring")
prev_dir = property(get_prev_dir, set_prev_dir, del_prev_dir,
"prev_dir's docstring")
curr_dir = property(get_curr_dir, set_curr_dir, del_curr_dir,
"curr_dir's docstring")
master_ext = property(get_master_ext, set_master_ext, del_master_ext,
"master_ext's docstring")
type_s = property(get_type_s, set_type_s, del_type_s, "type_s's docstring")
# Import module
from nudenet import NudeClassifier
# initialize classifier (downloads the checkpoint file automatically the first time)
classifier = NudeClassifier()
# Classify single image
# dic = classifier.classify('test.jpg')
# print(dic)
# Returns {'path_to_image_1': {'safe': PROBABILITY, 'unsafe': PROBABILITY}}
# Classify multiple images (batch prediction)
# batch_size is optional; defaults to 4
# classifier.classify(['path_to_image_1', 'path_to_image_2'], batch_size=BATCH_SIZE)
# # Returns {'path_to_image_1': {'safe': PROBABILITY, 'unsafe': PROBABILITY},
# # 'path_to_image_2': {'safe': PROBABILITY, 'unsafe': PROBABILITY}}
# # Classify video
# # batch_size is optional; defaults to 4
dic = classifier.classify_video('p**n.mp4')
# print("\n\n\n")
# for key, value in dic['preds'].items():
# print('프레임 {}의 결과 값은 {} 입니다'.format(key, value))
count = 0
num_frames = 0
for key, value in dic['preds'].items():
if float(value['unsafe']) > 0.6:
count += 1
num_frames += 1
import os
import tensorflow as tf
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
from nudenet import NudeClassifier
classifier = NudeClassifier()
result = classifier.classify('/nsfw/one.jpg')
result2 = classifier.classify('/nsfw/two.xjpg')
print('')
print('')
print('TEST RESULTS:')
print('********************************************')
print('')
print('one.jpg')
print(result)
print('')
print('two.xjpg')
print(result2)
print('')
print('********************************************')
print('')
def main(SUBREDDIT_NAMES):
tempjpg = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'temp.jpg')
classifier = NudeClassifier()
valid_extensions = ['.jpg', '.jpeg', '.bmp', '.png', '.tiff']
SUBREDDIT_NAMES = SUBREDDIT_NAMES.replace(',', '+').replace(' ', '')
while True:
con = sqlite3.connect('log.db')
cur = con.cursor()
try:
for submission in reddit.subreddit(
SUBREDDIT_NAMES).stream.submissions():
gallery = []
URL = submission.url
#add .jpg to image link if its an imgur link
if 'imgur.com' in URL:
URL += '.jpg'
gallery.append(URL)
#get inidividual images from gallery
elif 'reddit.com/gallery' in URL:
ids = [
i['media_id'] for i in submission.gallery_data['items']
]
for i in ids:
try:
url = submission.media_metadata[i]['p'][0]['u']
url = url.split("?")[0].replace("preview", "i")
gallery.append(url)
except KeyError:
pass
#normal image url
else:
gallery.append(URL)
for i in gallery:
isimage = False
if i.endswith(tuple(valid_extensions)):
isimage = True
if isimage == True:
try:
#save image as temp file
with urllib.request.urlopen(i) as url:
with open(tempjpg, 'wb') as f:
f.write(url.read())
f.close()
except Exception as err:
print(err)
prediction = classifier.classify(
tempjpg)[tempjpg]['unsafe']
#remove post if REMOVE_SUBMISSION is True
if prediction > NSFW_PROB_THRESHOLD:
#print("nsfw")
if LOGGING_ON:
cur.execute(
"INSERT INTO logbook VALUES (?,?,?)",
(submission.created_utc,
str(submission.author),
submission.permalink))
con.commit()
if not MOD_TEST:
submission.mod.nsfw()
if REMOVE_SUBMISSION:
submission.mod.remove()
submission.mod.send_removal_message(
REMOVAL_MESSAGE)
#send mod mail to mod discussions for testing
else:
submission.subreddit.message(
"NSFW image detected!",
"post: " + submission.permalink + ' p = ' +
str(prediction) +
', threshold is currently ' +
str(NSFW_PROB_THRESHOLD))
break
else:
#print("notnsfw")
pass
except Exception as err:
con.close()
print(err)
con.close()
class Nudity(commands.Cog):
"""Monitor images for NSFW content and moves them to a nsfw channel if possible"""
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self, identifier=9811198108111121, force_registration=True)
default_guild = {"enabled": False, "channel_id": None}
self.config.register_guild(**default_guild)
# self.detector = NudeDetector()
self.classifier = NudeClassifier()
self.data_path: pathlib.Path = cog_data_path(self)
self.current_processes = 0
async def red_delete_data_for_user(self, **kwargs):
"""Nothing to delete"""
return
@commands.command(aliases=["togglenudity"], name="nudity")
async def nudity(self, ctx: commands.Context):
"""Toggle nude-checking on or off"""
is_on = await self.config.guild(ctx.guild).enabled()
await self.config.guild(ctx.guild).enabled.set(not is_on)
await ctx.send("Nude checking is now set to {}".format(not is_on))
@commands.command()
async def nsfwchannel(self, ctx: commands.Context, channel: discord.TextChannel = None):
if channel is None:
await self.config.guild(ctx.guild).channel_id.set(None)
await ctx.send("NSFW Channel cleared")
else:
if not channel.is_nsfw():
await ctx.send("This channel isn't NSFW!")
return
else:
await self.config.guild(ctx.guild).channel_id.set(channel.id)
await ctx.send("NSFW channel has been set to {}".format(channel.mention))
async def get_nsfw_channel(self, guild: discord.Guild):
channel_id = await self.config.guild(guild).channel_id()
if channel_id is None:
return None
else:
return guild.get_channel(channel_id=channel_id)
async def nsfw(self, message: discord.Message, images: dict):
content = message.content
guild: discord.Guild = message.guild
if not content:
content = "*`None`*"
try:
await message.delete()
except discord.Forbidden:
await message.channel.send("NSFW Image detected!")
return
embed = discord.Embed(title="NSFW Image Detected")
embed.add_field(name="Original Message", value=content)
embed.set_author(name=message.author.name, icon_url=message.author.avatar_url)
await message.channel.send(embed=embed)
nsfw_channel = await self.get_nsfw_channel(guild)
if nsfw_channel is None:
return
else:
for image, r in images.items():
if r["unsafe"] > 0.7:
await nsfw_channel.send(
"NSFW Image from {}".format(message.channel.mention),
file=discord.File(
image,
),
)
@commands.Cog.listener()
async def on_message(self, message: discord.Message):
is_private = isinstance(message.channel, discord.abc.PrivateChannel)
if not message.attachments or is_private or message.author.bot:
# print("did not qualify")
return
if await self.bot.cog_disabled_in_guild(self, message.guild):
return
try:
is_on = await self.config.guild(message.guild).enabled()
except AttributeError:
return
if not is_on:
print("Not on")
return
channel: discord.TextChannel = message.channel
if channel.is_nsfw():
print("nsfw channel is okay")
return
check_list = []
for attachment in message.attachments:
# async with aiohttp.ClientSession() as session:
# img = await fetch_img(session, attachment.url)
ext = attachment.filename
temp_name = self.data_path / f"nudecheck{self.current_processes}_{ext}"
self.current_processes += 1
print("Pre attachment save")
await attachment.save(temp_name)
check_list.append(temp_name)
print("Pre nude check")
# nude_results = self.detector.detect(temp_name)
nude_results = self.classifier.classify([str(n) for n in check_list])
# print(nude_results)
if True in [r["unsafe"] > 0.7 for r in nude_results.values()]:
# print("Is nude")
await message.add_reaction("❌")
await self.nsfw(message, nude_results)
else:
# print("Is not nude")
await message.add_reaction("✅")
from nudenet import NudeClassifier
import sys
classifier = NudeClassifier()
print(classifier.classify("images/%s" % sys.argv[1]))