Added this webserver except it works

main.py

@@ -117,7 +117,7 @@ if __name__ == '__main__':
             trainer.test(test_loader)
             
             if opt.save_mesh:
-                trainer.save_mesh(resolution=256)
+                trainer.save_mesh(resolution=32)
     
     else:
         
@@ -157,4 +157,4 @@ if __name__ == '__main__':
             trainer.test(test_loader)
 
             if opt.save_mesh:
-                trainer.save_mesh(resolution=256)
+                trainer.save_mesh(resolution=32)

server.cpp

@@ -0,0 +1,166 @@
+#include <cstdio>
+#include <iostream>
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <thread>
+#include <array>
+#include <queue>
+#include <mutex>
+#include <vector>
+#include <filesystem>
+#include <sstream>
+#define CROW_MAIN
+#include <crow.h>
+#include <ranges>
+#include "threadpool.h"
+using std::string;
+using std::mutex;
+using std::lock_guard;
+using std::make_shared;
+using std::queue;
+using std::vector;
+namespace fs = std::filesystem;
+namespace rv = std::ranges::views;
+static inline string exec(const char* cmd) {
+	std::array<char, 128> buffer;
+	std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
+	string result;
+	if (!pipe)
+		return "Command failed";
+	else {
+		while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
+			result += buffer.data();
+	}
+	return result;
+}
+
+constexpr auto reify(const std::ranges::range auto& r){ return vector(r.begin(), r.end()); }
+
+constexpr string strip(const string& s){ return s; }
+
+constexpr string strip(string s, char ch){
+	s.erase(std::remove_if(s.begin(), s.end(), [=](char c){ return c == ch; }), s.end());
+	return s;
+}
+
+constexpr string strip(string s, char ch, auto... chs){
+	return strip(strip(s, ch), chs...);
+}
+
+constexpr vector<string> splitOn(const string& s, const string& delim){
+	vector<string> ret;
+	long long int start = 0;
+	for(size_t dp = s.find_first_of(delim, 0); start >= 0
+	   ; start = (dp == std::string::npos) ? -1 : dp + 1, dp = s.find_first_of(delim, start))
+		if(auto n = s.substr(start, dp - start); !n.empty())
+			ret.emplace_back(n);
+	return ret;
+}
+
+static inline string reset = "rm -rf trial/checkpoints/*";
+
+static inline string train(const string& prompt){
+	return string("python main.py --cuda_ray --save_mesh --text \"") + strip(prompt, '\'', '\"') + "\" --workspace trial -O";
+}
+
+static inline string save(const string& name){ return string("zip ") + name + ".zip trial/mesh/*"; }
+
+template <typename T>
+constexpr auto q_to_v(queue<T> qcopy){
+	vector<T> v;
+	v.reserve(qcopy.size());
+	while(!qcopy.empty())
+		v.push_back(qcopy.front()), qcopy.pop();
+	return v;
+}
+
+int main(){
+	crow::SimpleApp app;
+	typedef std::array<string, 2> guy;
+	auto commissions = make_shared<queue<guy>>();
+	auto queue_mutex = make_shared<mutex>()
+	   , train_mutex = make_shared<mutex>();
+	auto pool = make_shared<threadpool<>>(2);
+	auto run = [=](const string& cmd){
+		CROW_LOG_INFO << "running \'" << cmd;
+		return exec(cmd.c_str());
+	};
+
+	auto check_queue = [=](const string& name) -> int {
+		if(!commissions->empty()){
+			const auto v = q_to_v(*commissions);
+			if(auto pos = std::find_if( v.begin(), v.end()
+									  , [=](const guy& g){ auto& [n,d] = g; return n == name; });
+			pos != v.end())
+				return int(std::distance(v.begin(), pos));
+		}
+		return -1;
+	};
+
+	auto poppe = [=](){
+		lock_guard<mutex> qlock(*queue_mutex);
+		commissions->pop();
+		CROW_LOG_INFO << commissions->size() << " left in queue";
+	};
+
+	auto training_loop = [=](){
+		lock_guard<mutex> lock(*train_mutex);
+		while(!commissions->empty()){
+			auto& [name, prompt] = commissions->front();
+			CROW_LOG_INFO << "Launched training for " + name;
+			run(reset), run(train(prompt)), run(save(name));
+			CROW_LOG_INFO << "Finished training for " + name;
+			poppe();
+		}
+	};
+
+	auto enqueue = [=](const guy& thing){
+		lock_guard<mutex> lock(*queue_mutex);
+		commissions->push(thing);
+		auto& [name, prompt] = thing;
+		CROW_LOG_INFO << name << " queued with prompt: " << prompt;
+	};
+
+	CROW_ROUTE(app, "/create/<string>")
+		.methods("GET"_method, "POST"_method)([=](const crow::request& req, const string& name){
+			CROW_LOG_INFO << name << " commissioned";
+			if(auto prompt = req.url_params.get("prompt"); prompt == nullptr){
+				CROW_LOG_INFO << "No prompt specified";
+				return "Error: Can't train a NeRF for " + name + " without a prompt!";
+			} else {
+				if(auto r = check_queue(name); r < 0){
+					enqueue({name, prompt});
+					pool->enqueue(training_loop);
+					CROW_LOG_INFO << "Launched training loop";
+					return "Scheduled training for " + name;
+				} else
+					return name + " is currently " 
+								+ (r ? string("in line") : string("training"));
+			}
+		});
+
+	CROW_ROUTE(app, "/check/<string>")([=](crow::response& res, const string& name){
+		CROW_LOG_INFO << name << " check'd";
+		if(fs::exists(fs::path(name + ".zip"))){
+			res.write("O I know that guy");
+			res.set_static_file_info(name + ".zip");
+		} else if(auto r = check_queue(name); r < 0)
+			res.write("Doesn't look like much of anything to me");
+		else
+			res.write(name + " is currently "
+						   + (r ? string("in line") : string("training")));
+		res.end();
+	});
+
+	CROW_ROUTE(app, "/list")([&](){
+		std::vector<string> fin = splitOn(exec("ls *zip"), "\n")
+						  , q = reify(q_to_v(*commissions) | rv::transform([](const guy& i){ return i[0]; }));
+		crow::json::wvalue ret;
+		ret["finished"] = fin;
+		ret["pending"] = q;
+		return ret;
+	});
+
+	app.port(80).run();
+}

threadpool.h

@@ -0,0 +1,145 @@
+#pragma once
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <mutex>
+#include <queue>
+#include <utility>
+#include <vector>
+#include <concepts>
+#include <thread>
+static inline size_t avail_threads(){
+	return std::thread::hardware_concurrency();
+}
+
+template <typename F, typename... Args>
+using irt = std::invoke_result_t<F, Args...>;
+
+template <typename F, typename... Args>
+static inline auto taskify(const F& funk, Args... args){
+	return std::bind(funk, std::forward<Args...>(args)...);
+}
+
+static inline auto promitask(const std::invocable<> auto& funk){
+	typedef irt<decltype(funk)> ret;
+	auto pr = std::make_shared<std::promise<ret>>();
+	if constexpr (std::same_as<irt<decltype(funk)>, void>)
+		return make_pair([=](){ funk(), pr->set_value(); }, pr);
+	else
+		return make_pair([=](){ pr->set_value(funk()); }, pr);
+}
+
+static inline auto await_many(const std::ranges::range auto& fu){
+	std::for_each(fu.begin(), fu.end(), [](auto&& f){ f.wait(); });
+}
+
+typedef std::function<void()> tasque;
+
+template <typename Thrd = std::jthread>
+class threadpool {
+	/// If true the queue thread should exit
+	std::atomic<bool> done;
+
+	/// The thread object associated with this queue
+	std::vector<Thrd> queue_threads;
+	/// A queue of functions that will be executed on the queue thread
+	std::queue<tasque> work_queue;
+
+	/// The mutex used in the condition variable
+	std::mutex queue_mutex;
+
+	/// The condition variable that waits for a new function to be inserted in the
+	/// queue
+	std::condition_variable cond;
+
+	/// This funciton executes on the queue_thread
+	void queue_runner() {
+		while (!done) {
+			tasque func;
+			{
+				std::unique_lock<std::mutex> lock(queue_mutex);
+				cond.wait( lock
+						 , [this]() { return work_queue.empty() == false || done; });
+
+				if (!done){
+					swap(func, work_queue.front());
+					work_queue.pop();
+				}
+			}
+			if (func) func();
+		}
+	}
+
+	void qup(const std::invocable<> auto& f){
+		std::lock_guard<std::mutex> lock(queue_mutex);
+		work_queue.push(f);
+		cond.notify_one();
+	}
+
+public:
+	template <typename F, typename... Args>
+	void enqueue(const F& func, Args... args) requires std::invocable<F, Args...> {
+		qup(taskify(func, args...));
+	}
+
+	template <typename F, typename... Args>
+	auto inquire(const F& func, Args... args) requires std::invocable<F, Args...> {
+		auto [t, pr] = promitask(taskify(func, args...));
+		auto fut = pr->get_future();
+		enqueue(t);
+		return fut;
+	}
+
+	void clear() {
+		{
+			std::lock_guard<std::mutex> lock(queue_mutex);
+			while(!work_queue.empty())
+				work_queue.pop();
+		}
+		sync();
+	}
+
+	void sync(){
+		std::atomic<size_t> n(0);
+		const size_t m = queue_threads.size();
+		auto present = [&](){ ++n; size_t l = n.load(); while(l < m) l = n.load(); };
+		std::vector<std::future<void>> fu;
+		std::ranges::generate_n(std::back_inserter(fu), m, [=, this](){ return inquire(present); });
+		await_many(fu);
+	}
+
+	threadpool(size_t n, size_t res) : done(false)
+									 , queue_threads(n ? std::clamp(n, size_t(1), avail_threads() - res)
+													   : std::max(size_t(1), avail_threads() - res)) {
+		for(auto& i:queue_threads){
+			Thrd tmp(&threadpool::queue_runner, this);
+			std::swap(i, tmp);
+		}
+	}
+	threadpool(size_t n) : threadpool(n, 0) {}
+	threadpool() : threadpool(0, 1) {}
+
+	~threadpool() {
+		sync();
+		done.store(true);
+		cond.notify_all();
+	}
+
+	threadpool(const threadpool& other) : work_queue(other.work_queue), done(false) {
+		for(auto& i:queue_threads){
+			Thrd tmp(&threadpool::queue_runner, this);
+			std::swap(i, tmp);
+		}
+	}
+
+	threadpool& operator=(const threadpool& other){
+		clear();
+		work_queue = other.work_queue;
+		return *this;
+	}
+	size_t size() const { return queue_threads.size(); }
+	threadpool& operator=(threadpool&& other) = default;
+	threadpool(threadpool&& other) = default;
+};
+