gooberinc/goober
3
0
Fork 1
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #13 from gooberinc/dev

Browse source 
Dev
This commit is contained in:
WhatDidYouExpect 2025-07-09 15:05:36 +02:00 • committed by GitHub
commit 57c7196c5c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 156 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -12,3 +12,4 @@ received_memory.json
translation_report.txt
translationcompleteness.py
modules/volta
log.txt

70
bot.py
View file

@ -11,9 +11,25 @@ import uuid
import asyncio
import sys
from typing import List, Dict, Set, Optional, Tuple, Any, Union, Callable, Coroutine, TypeVar, Type
import logging
from modules.globalvars import *
from modules.prestartchecks import start_checks
from modules.logger import GooberFormatter
import logging
logger = logging.getLogger("goober")
logger.setLevel(logging.DEBUG)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(GooberFormatter())
file_handler = logging.FileHandler("log.txt", mode="w+", encoding="UTF-8")
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(GooberFormatter(colors=False))
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# Print splash text and check for updates
print(splashtext) # Print splash text (from modules/globalvars.py)
@ -65,7 +81,7 @@ bot: commands.Bot = commands.Bot(
memory: List[str] = load_memory()
markov_model: Optional[markovify.Text] = load_markov_model()
if not markov_model:
print(f"{RED}{(_('markov_model_not_found'))}{RESET}")
logger.error(_('markov_model_not_found'))
memory = load_memory()
markov_model = train_markov_model(memory)
@ -79,9 +95,9 @@ async def load_cogs_from_folder(bot, folder_name="assets/cogs"):
module_path = folder_name.replace("/", ".").replace("\\", ".") + f".{cog_name}"
try:
await bot.load_extension(module_path)
print(f"{GREEN}{(_('loaded_cog'))} {cog_name}{RESET}")
logger.info(f"{(_('loaded_cog'))} {cog_name}")
except Exception as e:
print(f"{RED}{(_('cog_fail'))} {cog_name} {e}{RESET}")
logger.error(f"{(_('cog_fail'))} {cog_name} {e}")
traceback.print_exc()
async def fetch_active_users() -> str:
@ -92,7 +108,7 @@ async def fetch_active_users() -> str:
else:
return "?"
except Exception as e:
print(f"{RED}{(_('error_fetching_active_users'))}{RESET} {e}")
logger.e(f"{_('error_fetching_active_users')} {RESET} {e}")
return "?"
async def send_alive_ping_periodically() -> None:
@ -100,7 +116,7 @@ async def send_alive_ping_periodically() -> None:
try:
requests.post(f"{VERSION_URL}/aliveping", json={"name": NAME})
except Exception as e:
print(f"{RED}{(_('error_sending_alive_ping'))}{RESET} {e}")
logger.error(f"{(_('error_sending_alive_ping'))}{RESET} {e}")
await asyncio.sleep(60)
# Event: Called when the bot is ready
@ -117,21 +133,21 @@ async def on_ready() -> None:
await load_cogs_from_folder(bot)
try:
synced: List[discord.app_commands.AppCommand] = await bot.tree.sync()
print(f"{GREEN}{_('synced_commands')} {len(synced)} {(_('synced_commands2'))} {RESET}")
logger.info(f"{_('synced_commands')} {len(synced)} {(_('synced_commands2'))}")
slash_commands_enabled = True
ping_server() # ping_server from modules/central.py
active_users: str = await fetch_active_users()
print(f"{GREEN}{(_('active_users:'))} {active_users}{RESET}")
print(f"{GREEN}{(_('started')).format(name=NAME)}{RESET}")
logger.info(f"{(_('active_users:'))} {active_users}")
logger.info(f"{(_('started')).format(name=NAME)}")
bot.loop.create_task(send_alive_ping_periodically())
except discord.errors.Forbidden as perm_error:
print(f"{RED}Permission error while syncing commands: {perm_error}{RESET}")
print(f"{RED}Make sure the bot has the 'applications.commands' scope and is invited with the correct permissions.{RESET}")
logger.error(f"Permission error while syncing commands: {perm_error}")
logger.error("Make sure the bot has the 'applications.commands' scope and is invited with the correct permissions.")
quit()
except Exception as e:
print(f"{RED}{(_('fail_commands_sync'))} {e}{RESET}")
logger.error(f"{_('fail_commands_sync')} {e}")
traceback.print_exc()
quit()
@ -181,13 +197,13 @@ async def retrain(ctx: commands.Context) -> None:
for i, data in enumerate(memory):
processed_data += 1
if processed_data % 1000 == 0 or processed_data == data_size:
await send_message(ctx, f"{(_('command_markov_retraining')).format(processed_data=processed_data, data_size=data_size)}", edit=True, message_reference=processing_message_ref)
await send_message(ctx, f"{_('command_markov_retraining').format(processed_data=processed_data, data_size=data_size)}", edit=True, message_reference=processing_message_ref)
global markov_model
markov_model = train_markov_model(memory)
save_markov_model(markov_model)
await send_message(ctx, f"{(_('command_markov_retrain_successful')).format(data_size=data_size)}", edit=True, message_reference=processing_message_ref)
await send_message(ctx, f"{_('command_markov_retrain_successful').format(data_size=data_size)}", edit=True, message_reference=processing_message_ref)
# Command: Generate a sentence using the Markov model
@bot.hybrid_command(description=f"{(_('command_desc_talk'))}")
@ -219,7 +235,7 @@ async def talk(ctx: commands.Context, sentence_size: int = 5) -> None:
combined_message: str = f"{coherent_response}\n[jif]({gif_url})"
else:
combined_message: str = coherent_response
print(combined_message)
logger.info(combined_message)
os.environ['gooberlatestgen'] = combined_message
await send_message(ctx, combined_message)
else:
@ -247,7 +263,7 @@ async def impact(ctx: commands.Context) -> None:
else:
fallback_image: Optional[str] = get_random_asset_image()
if fallback_image is None:
await ctx.reply((_('no_image_available')))
await ctx.reply(_('no_image_available'))
return
temp_input = tempfile.mktemp(suffix=os.path.splitext(fallback_image)[1])
shutil.copy(fallback_image, temp_input)
@ -255,7 +271,7 @@ async def impact(ctx: commands.Context) -> None:
else:
fallback_image = get_random_asset_image()
if fallback_image is None:
await ctx.reply((_('no_image_available')))
await ctx.reply(_('no_image_available'))
return
temp_input = tempfile.mktemp(suffix=os.path.splitext(fallback_image)[1])
shutil.copy(fallback_image, temp_input)
@ -266,7 +282,7 @@ async def impact(ctx: commands.Context) -> None:
if output_path is None or not os.path.isfile(output_path):
if temp_input and os.path.exists(temp_input):
os.remove(temp_input)
await ctx.reply((_('failed_generate_image')))
await ctx.reply(_('failed_generate_image'))
return
await ctx.send(file=discord.File(output_path))
@ -296,7 +312,7 @@ async def demotivator(ctx: commands.Context) -> None:
else:
fallback_image: Optional[str] = get_random_asset_image()
if fallback_image is None:
await ctx.reply((_('no_image_available')))
await ctx.reply(_('no_image_available'))
return
temp_input = tempfile.mktemp(suffix=os.path.splitext(fallback_image)[1])
shutil.copy(fallback_image, temp_input)
@ -304,7 +320,7 @@ async def demotivator(ctx: commands.Context) -> None:
else:
fallback_image = get_random_asset_image()
if fallback_image is None:
await ctx.reply((_('no_image_available')))
await ctx.reply(_('no_image_available'))
return
temp_input = tempfile.mktemp(suffix=os.path.splitext(fallback_image)[1])
shutil.copy(fallback_image, temp_input)
@ -375,7 +391,7 @@ async def on_message(message: discord.Message) -> None:
return
if message.content.startswith((f"{PREFIX}talk", f"{PREFIX}mem", f"{PREFIX}help", f"{PREFIX}stats", f"{PREFIX}")):
print(f"{(_('command_ran')).format(message=message)}")
logger.info(f"{(_('command_ran')).format(message=message)}")
await bot.process_commands(message)
return
@ -399,14 +415,14 @@ async def on_message(message: discord.Message) -> None:
try:
await message.add_reaction(emoji)
except Exception as e:
print(f"Failed to react with emoji: {e}")
logger.info(f"Failed to react with emoji: {e}")
await bot.process_commands(message)
# Event: Called on every interaction (slash command, etc.)
@bot.event
async def on_interaction(interaction: discord.Interaction) -> None:
print(f"{(_('command_ran_s')).format(interaction=interaction)}{interaction.data['name']}")
logger.info(f"{(_('command_ran_s')).format(interaction=interaction)}{interaction.data['name']}")
# Global check: Block blacklisted users from running commands
@bot.check
@ -415,11 +431,11 @@ async def block_blacklisted(ctx: commands.Context) -> bool:
try:
if isinstance(ctx, discord.Interaction):
if not ctx.response.is_done():
await ctx.response.send_message((_('blacklisted')), ephemeral=True)
await ctx.response.send_message(_('blacklisted'), ephemeral=True)
else:
await ctx.followup.send((_('blacklisted')), ephemeral=True)
await ctx.followup.send(_('blacklisted'), ephemeral=True)
else:
await ctx.send((_('blacklisted_user')), ephemeral=True)
await ctx.send(_('blacklisted_user'), ephemeral=True)
except:
pass
return False
@ -483,7 +499,7 @@ async def mem(ctx: commands.Context) -> None:
return
command: str = """curl -F "reqtype=fileupload" -F "time=1h" -F "fileToUpload=@memory.json" https://litterbox.catbox.moe/resources/internals/api.php"""
memorylitter: subprocess.CompletedProcess = subprocess.run(command, shell=True, capture_output=True, text=True)
print(memorylitter)
logger.debug(memorylitter)
await send_message(ctx, memorylitter.stdout.strip())
# Helper: Improve sentence coherence (simple capitalization fix)

24
modules/central.py
View file

@ -3,17 +3,19 @@ import os
import modules.globalvars as gv
from modules.volta.main import _
from modules.markovmemory import get_file_info
import logging
logger = logging.getLogger("goober")
# Ping the server to check if it's alive and send some info
def ping_server():
if gv.ALIVEPING == "false":
# If pinging is disabled, print message and set environment variable
print(f"{gv.YELLOW}{(_('pinging_disabled'))}{gv.RESET}")
print(f"{gv.YELLOW}{(_('pinging_disabled'))}")
os.environ['gooberauthenticated'] = 'No'
return
# Get server alert message
goobres = requests.get(f"{gv.VERSION_URL}/alert")
print(f"{(_('goober_server_alert'))}{goobres.text}")
logger.info(f"{(_('goober_server_alert'))}{goobres.text}")
# Gather file info for payload
file_info = get_file_info(gv.MEMORY_FILE)
payload = {
@ -28,15 +30,15 @@ def ping_server():
response = requests.post(gv.VERSION_URL+"/ping", json=payload)
if response.status_code == 200:
# Success: print message and set environment variable
print(f"{gv.GREEN}{(_('goober_ping_success')).format(NAME=gv.NAME)}{gv.RESET}")
logger.info(f"{(_('goober_ping_success')).format(NAME=gv.NAME)}")
os.environ['gooberauthenticated'] = 'Yes'
else:
# Failure: print error and set environment variable
print(f"{gv.RED}{(_('goober_ping_fail'))} {response.status_code}{gv.RESET}")
logger.error(f"{(_('goober_ping_fail'))} {response.status_code}")
os.environ['gooberauthenticated'] = 'No'
except Exception as e:
# Exception: print error and set environment variable
print(f"{gv.RED}{(_('goober_ping_fail2'))} {str(e)}{gv.RESET}")
logger.error(f"{(_('goober_ping_fail2'))} {str(e)}")
os.environ['gooberauthenticated'] = 'No'
# Check if a given name is available for registration
@ -52,11 +54,11 @@ def is_name_available(NAME):
return data.get("available", False)
else:
# Print error if request failed
print(f"{(_('name_check'))}", response.json())
logger.e(f"{(_('name_check'))}", response.json())
return False
except Exception as e:
# Print exception if request failed
print(f"{(_('name_check2'))}", e)
logger.error(f"{(_('name_check2'))}", e)
return False
# Register a new name with the server
@ -70,7 +72,7 @@ def register_name(NAME):
if os.getenv("gooberTOKEN"):
return
# Name taken: print error and exit
print(f"{gv.RED}{(_('name_taken'))}{gv.RESET}")
logger.critical(f"{(_('name_taken'))}")
quit()
# Register the name
response = requests.post(f"{gv.VERSION_URL}/register", json={"name": NAME}, headers={"Content-Type": "application/json"})
@ -79,18 +81,18 @@ def register_name(NAME):
token = data.get("token")
if not os.getenv("gooberTOKEN"):
# Print instructions to add token and exit
print(f"{gv.GREEN}{(_('add_token')).format(token=token)} gooberTOKEN=<token>.{gv.gv.RESET}")
logger.info(f"{(_('add_token')).format(token=token)} gooberTOKEN=<token>.")
quit()
else:
print(f"{gv.GREEN}{gv.gv.RESET}")
return token
else:
# Print error if registration failed
print(f"{gv.RED}{(_('token_exists')).format()}{gv.RESET}", response.json())
logger.critical(f"{gv.RED}{(_('token_exists')).format()}", response.json())
return None
except Exception as e:
# Print exception if registration failed
print(f"{gv.RED}{(_('registration_error')).format()}{gv.RESET}", e)
logger.critical(f"{gv.RED}{(_('registration_error')).format()}", e)
return None
# Attempt to register the name at module load

3
modules/globalvars.py
View file

@ -10,6 +10,7 @@ ANSI = "\033["
RED = f"{ANSI}31m"
GREEN = f"{ANSI}32m"
YELLOW = f"{ANSI}33m"
PURPLE = f"{ANSI}35m"
DEBUG = f"{ANSI}1;30m"
RESET = f"{ANSI}0m"
VERSION_URL = "https://goober.expect.ovh"
@ -40,5 +41,5 @@ latest_version = "0.0.0"
local_version = "2.1.3"
os.environ['gooberlocal_version'] = local_version
REACT = os.getenv("REACT")
beta = False # this makes goober think its a beta version, so it will not update to the latest stable version or run any version checks
beta = True # this makes goober think its a beta version, so it will not update to the latest stable version or run any version checks

25
modules/logger.py Normal file
View file

@ -0,0 +1,25 @@
import logging
from modules.globalvars import *
class GooberFormatter(logging.Formatter):
def __init__(self, colors: bool = True): # Disable colors for TXT output
self.colors = colors
self._format = f"[ %(levelname)-8s ]: %(message)s {DEBUG} [%(asctime)s.%(msecs)03d] (%(filename)s:%(funcName)s) {RESET}"
self.FORMATS = {
logging.DEBUG: DEBUG + self._format + RESET,
logging.INFO: self._format.replace("%(levelname)-8s", f"{GREEN}%(levelname)-8s{RESET}"),
logging.WARNING: YELLOW + self._format + RESET,
logging.ERROR: RED + self._format + RESET,
logging.CRITICAL: PURPLE + self._format + RESET
}
def format(self, record: logging.LogRecord):
if self.colors:
log_fmt = self.FORMATS.get(record.levelno) # Add colors
else:
log_fmt = self._format # Just use the default format
formatter = logging.Formatter(log_fmt, datefmt="%m/%d/%y %H:%M:%S")
return formatter.format(record)

9
modules/markovmemory.py
View file

@ -4,7 +4,8 @@ import markovify
import pickle
from modules.globalvars import *
from modules.volta.main import _
import logging
logger = logging.getLogger("goober")
# Get file size and line count for a given file path
def get_file_info(file_path):
try:
@ -47,15 +48,15 @@ def train_markov_model(memory, additional_data=None):
def save_markov_model(model, filename='markov_model.pkl'):
with open(filename, 'wb') as f:
pickle.dump(model, f)
print(f"Markov model saved to {filename}.")
logger.info(f"Markov model saved to {filename}.")
# Load the Markov model from a pickle file
def load_markov_model(filename='markov_model.pkl'):
try:
with open(filename, 'rb') as f:
model = pickle.load(f)
print(f"{GREEN}{_('model_loaded')} {filename}.{RESET}")
logger.info(f"{_('model_loaded')} {filename}.{RESET}")
return model
except FileNotFoundError:
print(f"{RED}{filename} {_('not_found')}{RESET}")
logger.error(f"{filename} {_('not_found')}{RESET}")
return None

85
modules/prestartchecks.py
View file

@ -10,6 +10,9 @@ import json
import re
from spacy.util import is_package
import importlib.metadata
import logging
logger = logging.getLogger("goober")
# import shutil
psutilavaliable = True
@ -18,20 +21,20 @@ try:
import psutil
except ImportError:
psutilavaliable = False
print(RED, _('missing_requests_psutil'), RESET)
logger.error(_('missing_requests_psutil'))
def check_for_model():
if is_package("en_core_web_sm"):
print("Model is installed.")
logger.info("Model is installed.")
else:
print("Model is not installed.")
logger.info("Model is not installed.")
def iscloned():
if os.path.exists(".git"):
return True
else:
print(f"{RED}{(_('not_cloned'))}{RESET}")
logger.error(f"{_('not_cloned')}")
sys.exit(1)
def get_stdlib_modules():
@ -63,7 +66,7 @@ def check_requirements():
requirements_path = os.path.abspath(os.path.join(parent_dir, '..', 'requirements.txt'))
if not os.path.exists(requirements_path):
print(f"{RED}{(_('requirements_not_found')).format(path=requirements_path)}{RESET}")
logger.error(f"{(_('requirements_not_found')).format(path=requirements_path)}")
return
with open(requirements_path, 'r') as f:
@ -95,9 +98,9 @@ def check_requirements():
continue
requirements.add(pkg)
except Exception as e:
print(f"{YELLOW}{(_('warning_failed_parse_imports')).format(filename=filename, error=e)}{RESET}")
logger.warning(f"{(_('warning_failed_parse_imports')).format(filename=filename, error=e)}")
else:
print(f"{YELLOW}{(_('cogs_dir_not_found')).format(path=cogs_dir)}{RESET}")
logger.warning(f"{(_('cogs_dir_not_found')).format(path=cogs_dir)}")
installed_packages = {dist.metadata['Name'].lower() for dist in importlib.metadata.distributions()}
missing = []
@ -110,16 +113,16 @@ def check_requirements():
check_name = PACKAGE_ALIASES.get(req, req).lower()
if check_name in installed_packages:
print(f"[ {GREEN}{(_('ok_installed')).format(package=check_name)}{RESET} ] {check_name}")
logger.info(f"{_('ok_installed').format(package=check_name)} {check_name}")
else:
print(f"[ {RED}{(_('missing_package')).format(package=check_name)}{RESET} ] {check_name} {(_('missing_package2'))}")
logger.error(f"{(_('missing_package')).format(package=check_name)} {check_name} {(_('missing_package2'))}")
missing.append(check_name)
if missing:
print(RED, _('missing_packages_detected'), RESET)
logger.error(_('missing_packages_detected'))
for pkg in missing:
print(f" - {pkg}")
print((_('telling_goober_central')).format(url=VERSION_URL))
logger.info((_('telling_goober_central')).format(url=VERSION_URL))
payload = {
"name": NAME,
"version": local_version,
@ -129,10 +132,10 @@ def check_requirements():
try:
requests.post(VERSION_URL + "/ping", json=payload) # type: ignore
except Exception as e:
print(f"{RED}{(_('failed_to_contact')).format(url=VERSION_URL, error=e)}{RESET}")
logger.error(f"{(_('failed_to_contact')).format(url=VERSION_URL, error=e)}")
sys.exit(1)
else:
print(_('all_requirements_satisfied'))
logger.info(_('all_requirements_satisfied'))
def check_latency():
host = "1.1.1.1"
@ -158,16 +161,16 @@ def check_latency():
match = re.search(latency_pattern, result.stdout)
if match:
latency_ms = float(match.group(1))
print((_('ping_to')).format(host=host, latency=latency_ms))
logger.info((_('ping_to')).format(host=host, latency=latency_ms))
if latency_ms > 300:
print(f"{YELLOW}{(_('high_latency'))}{RESET}")
logger.warning(f"{(_('high_latency'))}")
else:
print(f"{YELLOW}{(_('could_not_parse_latency'))}{RESET}")
logger.warning((_('could_not_parse_latency')))
else:
print(result.stderr)
print(f"{RED}{(_('ping_failed')).format(host=host)}{RESET}")
logger.error(f"{(_('ping_failed')).format(host=host)}{RESET}")
except Exception as e:
print(f"{RED}{(_('error_running_ping')).format(error=e)}{RESET}")
logger.error((_('error_running_ping')).format(error=e))
def check_memory():
if psutilavaliable == False:
@ -178,21 +181,21 @@ def check_memory():
used_memory = memory_info.used / (1024 ** 3)
free_memory = memory_info.available / (1024 ** 3)
print((_('memory_usage')).format(used=used_memory, total=total_memory, percent=(used_memory / total_memory) * 100))
logger.info((_('memory_usage')).format(used=used_memory, total=total_memory, percent=(used_memory / total_memory) * 100))
if used_memory > total_memory * 0.9:
print(f"{YELLOW}{(_('memory_above_90')).format(percent=(used_memory / total_memory) * 100)}{RESET}")
print((_('total_memory')).format(total=total_memory))
print((_('used_memory')).format(used=used_memory))
logger.info((_('total_memory')).format(total=total_memory))
logger.info((_('used_memory')).format(used=used_memory))
if free_memory < 1:
print(f"{RED}{(_('low_free_memory')).format(free=free_memory)}{RESET}")
logger.warning(f"{(_('low_free_memory')).format(free=free_memory)}")
sys.exit(1)
except ImportError:
print(_('psutil_not_installed')) # todo: translate this into italian and put it in the translations "psutil is not installed. Memory check skipped."
logger.error(_('psutil_not_installed')) # todo: translate this into italian and put it in the translations "psutil is not installed. Memory check skipped."
def check_cpu():
if psutilavaliable == False:
return
print((_('measuring_cpu')))
logger.info((_('measuring_cpu')))
cpu_per_core = psutil.cpu_percent(interval=1, percpu=True) # type: ignore
for idx, core_usage in enumerate(cpu_per_core):
bar_length = int(core_usage / 5)
@ -203,33 +206,33 @@ def check_cpu():
color = YELLOW
else:
color = GREEN
print((_('core_usage')).format(idx=idx, bar=bar, usage=core_usage))
logger.info((_('core_usage')).format(idx=idx, bar=bar, usage=core_usage))
total_cpu = sum(cpu_per_core) / len(cpu_per_core)
print((_('total_cpu_usage')).format(usage=total_cpu))
logger.info((_('total_cpu_usage')).format(usage=total_cpu))
if total_cpu > 85:
print(f"{YELLOW}{(_('high_avg_cpu')).format(usage=total_cpu)}{RESET}")
logger.warning(f"{(_('high_avg_cpu')).format(usage=total_cpu)}")
if total_cpu > 95:
print(f"{RED}{(_('really_high_cpu'))}{RESET}")
logger.error(_('really_high_cpu'))
sys.exit(1)
def check_memoryjson():
try:
print((_('memory_file')).format(size=os.path.getsize(MEMORY_FILE) / (1024 ** 2)))
logger.info((_('memory_file')).format(size=os.path.getsize(MEMORY_FILE) / (1024 ** 2)))
if os.path.getsize(MEMORY_FILE) > 1_073_741_824:
print(f"{YELLOW}{(_('memory_file_large'))}{RESET}")
logger.warning(f"{(_('memory_file_large'))}")
try:
with open(MEMORY_FILE, 'r', encoding='utf-8') as f:
json.load(f)
except json.JSONDecodeError as e:
print(f"{RED}{(_('memory_file_corrupted')).format(error=e)}{RESET}")
print(f"{YELLOW}{(_('consider_backup_memory'))}{RESET}")
logger.error(f"{(_('memory_file_corrupted')).format(error=e)}")
logger.warning(f"{(_('consider_backup_memory'))}")
except UnicodeDecodeError as e:
print(f"{RED}{(_('memory_file_encoding')).format(error=e)}{RESET}")
print(f"{YELLOW}{(_('consider_backup_memory'))}{RESET}")
logger.error(f"{(_('memory_file_encoding')).format(error=e)}")
logger.warning(f"{(_('consider_backup_memory'))}")
except Exception as e:
print(f"{RED}{(_('error_reading_memory')).format(error=e)}{RESET}")
logger.error(f"{(_('error_reading_memory')).format(error=e)}")
except FileNotFoundError:
print(f"{YELLOW}{(_('memory_file_not_found'))}{RESET}")
logger(f"{(_('memory_file_not_found'))}")
def presskey2skip(timeout):
if os.name == 'nt':
@ -265,9 +268,9 @@ def presskey2skip(timeout):
beta = beta
def start_checks():
if CHECKS_DISABLED == "True":
print(f"{YELLOW}{(_('checks_disabled'))}{RESET}")
logger.warning(f"{(_('checks_disabled'))}")
return
print(_('running_prestart_checks'))
logger.info(_('running_prestart_checks'))
check_for_model()
iscloned()
check_missing_translations()
@ -279,13 +282,13 @@ def start_checks():
if os.path.exists(".env"):
pass
else:
print(f"{YELLOW}{(_('env_file_not_found'))}{RESET}")
logger.warning(f"{(_('env_file_not_found'))}")
sys.exit(1)
if beta == True:
print(f"{YELLOW}this build isnt finished yet, some things might not work as expected{RESET}")
logger.warning(f"this build isnt finished yet, some things might not work as expected")
else:
pass
print(_('continuing_in_seconds').format(seconds=5))
logger.info(_('continuing_in_seconds').format(seconds=5))
presskey2skip(timeout=5)
os.system('cls' if os.name == 'nt' else 'clear')
print(splashtext)

11
modules/sentenceprocessing.py
View file

@ -6,17 +6,20 @@ import spacy
from spacy.tokens import Doc
from spacytextblob.spacytextblob import SpacyTextBlob
import logging
logger = logging.getLogger("goober")
def check_resources():
try:
nlp = spacy.load("en_core_web_sm")
except OSError:
print((_('spacy_model_not_found')))
logging.critical((_('spacy_model_not_found')))
spacy.cli.download("en_core_web_sm")
nlp = spacy.load("en_core_web_sm")
if "spacytextblob" not in nlp.pipe_names:
nlp.add_pipe("spacytextblob")
print((_('spacy_initialized')))
logger.info((_('spacy_initialized')))
check_resources()
@ -28,8 +31,8 @@ def is_positive(sentence):
doc = nlp(sentence)
sentiment_score = doc._.polarity # from spacytextblob
debug_message = f"{DEBUG}{(_('sentence_positivity'))} {sentiment_score}{RESET}"
print(debug_message)
debug_message = f"{(_('sentence_positivity'))} {sentiment_score}{RESET}"
logger.debug(debug_message)
return sentiment_score > 0.6 # had to raise the bar because it kept saying "death to jews" was fine and it kept reacting to them

31
modules/version.py
View file

@ -3,7 +3,8 @@ from modules.globalvars import *
import requests
import subprocess
import sys
import logging
logger = logging.getLogger("goober")
launched = False
# Run a shell command and return its output
@ -27,11 +28,11 @@ def auto_update(branch='main', remote='origin'):
if is_remote_ahead(branch, remote):
print(_( "remote_ahead").format(remote=remote, branch=branch))
pull_result = run_cmd(f'git pull {remote} {branch}')
print(pull_result)
print(_( "please_restart"))
logger.info(pull_result)
logger.info(_( "please_restart"))
sys.exit(0)
else:
print(_( "local_ahead").format(remote=remote, branch=branch))
logger.info(_( "local_ahead").format(remote=remote, branch=branch))
# Fetch the latest version info from the update server
def get_latest_version_info():
@ -40,10 +41,10 @@ def get_latest_version_info():
if response.status_code == 200:
return response.json()
else:
print(f"{RED}{_( 'version_error')} {response.status_code}{RESET}")
logger.error(f"{RED}{_( 'version_error')} {response.status_code}{RESET}")
return None
except requests.RequestException as e:
print(f"{RED}{_( 'version_error')} {e}{RESET}")
logger.error(f"{RED}{_( 'version_error')} {e}{RESET}")
return None
# Check if an update is available and perform update if needed
@ -54,7 +55,7 @@ def check_for_update():
latest_version_info = get_latest_version_info()
if not latest_version_info:
print(f"{_('fetch_update_fail')}")
logger.error(f"{_('fetch_update_fail')}")
return None, None
latest_version = latest_version_info.get("version")
@ -62,25 +63,25 @@ def check_for_update():
download_url = latest_version_info.get("download_url")
if not latest_version or not download_url:
print(f"{RED}{_(LOCALE, 'invalid_server')}{RESET}")
logger.error(f"{RED}{_(LOCALE, 'invalid_server')}{RESET}")
return None, None
# Check if local_version is valid
if local_version == "0.0.0" or None:
print(f"{RED}{_('cant_find_local_version')}{RESET}")
logger.error(f"{RED}{_('cant_find_local_version')}{RESET}")
return
# Compare local and latest versions
if local_version < latest_version:
print(f"{YELLOW}{_('new_version').format(latest_version=latest_version, local_version=local_version)}{RESET}")
print(f"{YELLOW}{_('changelog').format(VERSION_URL=VERSION_URL)}{RESET}")
logger.info(f"{YELLOW}{_('new_version').format(latest_version=latest_version, local_version=local_version)}{RESET}")
logger.info(f"{YELLOW}{_('changelog').format(VERSION_URL=VERSION_URL)}{RESET}")
auto_update()
elif beta == True:
print(f"{YELLOW}You are running an \"unstable\" version of Goober, do not expect it to work properly.\nVersion {local_version}{RESET}")
logger.warning(f"You are running an \"unstable\" version of Goober, do not expect it to work properly.\nVersion {local_version}{RESET}")
elif local_version > latest_version:
print(f"{YELLOW}{_('modification_warning')}{RESET}")
logger.warning(f"{_('modification_warning')}")
elif local_version == latest_version:
print(f"{GREEN}{_('latest_version')} {local_version}{RESET}")
print(f"{_('latest_version2').format(VERSION_URL=VERSION_URL)}\n\n")
logger.info(f"{_('latest_version')} {local_version}")
logger.info(f"{_('latest_version2').format(VERSION_URL=VERSION_URL)}\n\n")
launched = True
return latest_version