astrospace 1.2.8__tar.gz

astrospace-1.2.8/.gitignore

@@ -0,0 +1,191 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+hatch.bat
+nginx/.env
+# C extensions
+*.so
+dist/
+instance/
+blogs/ 
+postgres/
+**/node_modules/
+**/uploads/
+**/watch.bat
+serve.bat 
+cmd.txt 
+.vscode/
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+publish/
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor  
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to 
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

astrospace-1.2.8/AstroSpace/__init__.py

@@ -0,0 +1,112 @@
+import os
+import logging
+from flask import Flask, jsonify, g
+from flask_wtf.csrf import CSRFProtect
+from werkzeug.exceptions import RequestEntityTooLarge
+from AstroSpace.logging_utils import configure_app_logging, debug_log
+
+csrf = CSRFProtect()
+
+
+def create_app(test_config=None):
+    # create and configure the app
+    app = Flask(__name__, instance_relative_config=True)
+
+    # first priority 
+    app.config.from_object('AstroSpace.config.Config') 
+
+    # second priority
+    # load the environment variables from the path set in environment variable
+    app.config.from_envvar('ASTROSPACE_SETTINGS', silent=True)
+
+    if test_config is None:
+        # load the instance config, if it exists, when not testing
+        app.config.from_pyfile('config.py', silent=True)
+    else:
+        # load the test config if passed in
+        app.config.from_mapping(test_config)
+    
+    app.config['root_path'] = os.path.dirname(__file__)
+    app.config['MAX_CONTENT_LENGTH'] = 2 *  (1024 ** 3) #about 2GB
+    configure_app_logging(app)
+
+    @app.errorhandler(RequestEntityTooLarge)
+    def handle_file_too_large(e):
+        return jsonify(error=f"Uploaded File is too large. Max size is {app.config['MAX_CONTENT_LENGTH']/(1024**3)} GB."), 413
+
+    #app.config['UPLOAD_PATH'] = os.path.join(app.root_path, 'uploads')
+    os.makedirs(app.config['UPLOAD_PATH'],exist_ok=True)
+    skip_db_init = app.config.get("SKIP_DB_INIT", False)
+    debug_log(
+        "Application configured (instance_path=%s, skip_db_init=%s, max_upload_bytes=%s)",
+        app.instance_path,
+        skip_db_init,
+        app.config["MAX_CONTENT_LENGTH"],
+    )
+
+    # ensure the instance folder exists
+    try:
+        os.makedirs(app.instance_path)
+    except OSError:
+        pass
+
+    for key in ['SECRET_KEY', 'DB_NAME', 'DB_USER', 'DB_PASSWORD', 'DB_HOST', 'DB_PORT']:
+        if key not in app.config:
+            raise ValueError(f"{key} must be set in the configuration", app.config)
+    if not app.config.get("SECRET_KEY"):
+        raise ValueError("SECRET_KEY must be set in the configuration")
+
+    csrf.init_app(app)
+
+    from . import db
+    if not skip_db_init:
+        db.init_app(app)
+
+        with app.app_context():
+            exists = db.check_images_table_exists()
+            debug_log("Database bootstrap check completed (images_table_exists=%s)", exists)
+            if not exists:
+                debug_log(
+                    "images table is missing; initializing database schema.",
+                    level=logging.INFO,
+                )
+                db.init_db()
+            db.ensure_runtime_schema()
+    
+    @app.before_request
+    def load_web_info():
+        if skip_db_init:
+            g.web_info = {}
+            return
+
+        conn = db.get_conn()
+        with conn.cursor() as cur:
+            cur.execute("SELECT * FROM web_info LIMIT 1")
+            info = cur.fetchone()
+
+        g.web_info = info or {}  # fallback to empty dict
+    
+    @app.context_processor
+    def inject_web_info():
+        return {
+            "web_info": getattr(g, "web_info", {})
+        }
+
+    from . import auth
+    app.register_blueprint(auth.bp)
+
+    from . import blog
+    app.register_blueprint(blog.bp)
+
+    from .profile import private, public
+    app.register_blueprint(private.bp)
+    app.register_blueprint(public.bp)
+
+    app.add_url_rule('/', endpoint='index')
+
+    return app
+
+
+if __name__ == "__main__":
+    app = create_app()
+    app.run(debug=True, host="0.0.0.0", port=9000)

astrospace-1.2.8/AstroSpace/__main__.py

@@ -0,0 +1,44 @@
+import logging
+import os
+import sys
+
+from AstroSpace.logging_utils import debug_log, runtime_debug_enabled, strip_debug_flag
+
+
+DEFAULT_GUNICORN_OPTIONS = [
+    "-w",
+    "3",
+    "-b",
+    "0.0.0.0:9000",
+    "--timeout",
+    "1000",
+    "--worker-class",
+    "gevent",
+]
+APP_TARGET = "AstroSpace:create_app()"
+
+
+def build_gunicorn_command(argv=None):
+    args = list(sys.argv[1:] if argv is None else argv)
+    filtered_args, flag_requested = strip_debug_flag(args)
+    debug_enabled = flag_requested or runtime_debug_enabled(filtered_args)
+
+    command = ["gunicorn", *DEFAULT_GUNICORN_OPTIONS]
+    if debug_enabled:
+        command.extend(["--log-level", "debug"])
+    command.extend(filtered_args)
+    command.append(APP_TARGET)
+    return command, debug_enabled
+
+
+def main(argv=None):
+    command, debug_enabled = build_gunicorn_command(argv)
+    if debug_enabled:
+        os.environ["ASTROSPACE_DEBUG"] = "1"
+        debug_log("Starting Gunicorn with AstroSpace debug logging enabled.", level=logging.INFO)
+
+    os.execvp(command[0], command)
+
+
+if __name__ == "__main__":
+    main()

astrospace-1.2.8/AstroSpace/auth.py

@@ -0,0 +1,105 @@
+import functools
+
+from psycopg2 import IntegrityError
+from flask import (
+    Blueprint, flash, g, redirect, render_template, request, session, url_for, current_app
+)
+from werkzeug.security import check_password_hash, generate_password_hash
+
+from AstroSpace.db import get_conn
+
+bp = Blueprint('auth', __name__, url_prefix='/auth')
+
+@bp.route('/register', methods=('GET', 'POST'))
+def register():
+    if request.method == 'POST':
+        username = request.form['username'].lower()
+        password = request.form['password']
+        db = get_conn()
+        error = None
+
+        if not username:
+            error = 'Username is required.'
+        elif not password:
+            error = 'Password is required.'
+
+        if error is None:
+            try:
+                with db.cursor() as cur:
+                    cur.execute("LOCK TABLE users IN EXCLUSIVE MODE")
+                    cur.execute("SELECT COUNT(*) AS user_count FROM users")
+                    user_count = cur.fetchone()["user_count"]
+
+                    if user_count >= current_app.config['MAX_USERS']:
+                        error = 'Sorry maximum number of users reached :('
+                    else:
+                        is_first_user = user_count == 0
+                        cur.execute(
+                            "INSERT INTO users (username, password, admin) VALUES (%s, %s, %s)",
+                            (username, generate_password_hash(password), is_first_user),
+                        )
+                if error is None:
+                    db.commit()
+                    return redirect(url_for("auth.login"))
+                db.rollback()
+            except IntegrityError:
+                db.rollback()
+                error = f"User {username} is already registered."
+
+        flash(error)
+
+    return render_template('auth/auth.html', title='Register', WebName = current_app.config["TITLE"])
+
+@bp.route('/login', methods=('GET', 'POST'))
+def login():
+    if request.method == 'POST':
+        username = request.form['username'].lower()
+        password = request.form['password']
+        db = get_conn()
+        error = None
+        with db.cursor() as cur:
+            cur.execute(
+                "SELECT * FROM users WHERE username = %s", (username,) )
+            user = cur.fetchone()
+        
+        if user is None:
+            error = 'Incorrect username.'
+        elif not check_password_hash(user['password'], password):
+            error = 'Incorrect password.'
+
+        if error is None:
+            session.clear()
+            session['user_id'] = user['id']
+            return redirect(url_for('index'))
+
+        flash(error)
+
+    return render_template('auth/auth.html', title='Log In', WebName = current_app.config["TITLE"])
+
+@bp.before_app_request
+def load_logged_in_user():
+    user_id = session.get('user_id')
+
+    if user_id is None:
+        g.user = None
+    else:
+        cur = get_conn().cursor()
+        cur.execute(
+            "SELECT * FROM users WHERE id = %s", (user_id,)
+        )
+        g.user = cur.fetchone()
+
+@bp.route('/logout', methods=('POST',))
+def logout():
+    session.clear()
+    return redirect(url_for('index'))
+
+def login_required(view):
+    @functools.wraps(view)
+    def wrapped_view(**kwargs):
+        if g.user is None:
+            return redirect(url_for('auth.login'))
+
+        return view(**kwargs)
+
+    return wrapped_view