Commit: 019d96c167ce1ca2e26231d1818442eb269ae86e - pixivd_tools (hg)

Auxiliary tools for users of pixiv_down

Commit MetaInfo

• Revision: 019d96c167ce1ca2e26231d1818442eb269ae86e (tree)
• Time: 2023-01-06 19:48:18
• Author: nemophila <stigma@disr...>
• Commiter: nemophila

Log Message

initial commit

Change Summary

• add: .hgignore
• add: LICENSE
• add: README
• add: dub.sdl
• add: dub.selections.json
• add: mlib/configparser.d
• add: mlib/directories.d
• add: mlib/dub.sdl
• add: pixiv_remove_unfollowed.d

Incremental Difference

diff -r 000000000000 -r 019d96c167ce .hgignore
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,11 @@
+# dub
+.dub/
+
+# mlib
+.a
+
+# Executables
+pixiv_remove_unfollowed
+
+# Logs
+.log

diff -r 000000000000 -r 019d96c167ce LICENSE
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LICENSE	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,26 @@
+Copyright 2023 mio <[e-mail]>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials
+       provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

diff -r 000000000000 -r 019d96c167ce README
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,24 @@
+- pixivd_tools -
+
+Auxiliary tools for [pixiv_down].
+
+[pixiv_down]: https://yume-neru.neocities.org/p/pixiv_down.html
+
+
+= Requirements =
+
+* A D compiler
+* dub
+* [pixivd]
+
+You'll need pixivd downloaded.  By defaut these tools will look for the
+directory at "../pixivd" (i.e. they'll look for "pixivd" in the parent
+directory).  You can change this in the "dub.sdl" file.
+
+[pixivd]: https://yume-neru.neocities.org/p/pixivd.html
+
+
+= License =
+
+Each tool is licensed under the BSD 2-Clause License, which
+you can read in the LICENSE file.

diff -r 000000000000 -r 019d96c167ce dub.sdl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dub.sdl	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,14 @@
+name "pixivd-tools"
+description "Collection of extra utility programs utilising pixivd"
+license "BSD 2-clause"
+
+# Change the path here for pixivd if required.
+dependency "pixivd" path="../pixivd"
+
+dependency "mlib" path="mlib"
+
+configuration "remove_unfollowed" {
+    sourceFiles "pixiv_remove_unfollowed.d"
+    targetType "executable"
+    targetName "pixiv_remove_unfollowed"
+}

diff -r 000000000000 -r 019d96c167ce dub.selections.json
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dub.selections.json	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,6 @@
+{
+	"fileVersion": 1,
+	"versions": {
+		"mlib": {"path":"mlib"}
+	}
+}

diff -r 000000000000 -r 019d96c167ce mlib/configparser.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mlib/configparser.d	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,644 @@
+/*
+ * Copyright (C) 2021, 2022 mio <[e-mail]>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is herby granted.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PEFORMANCE OF THIS SOFTWARE.
+ */
+
+
+/**
+ * An incomplete single-file INI parser for D.
+ *
+ * The API should be similar to python's configparse module.  Internally it
+ * uses the standard D associative array.
+ *
+ * Example:
+ * ---
+ * import configparser;
+ *
+ * auto config = new ConfigParser();
+ * // no sections initially
+ * assert(config.sections.length == 0);
+ * // Section names are case-sensitive
+ * conf.addSection("Default");
+ * // option names (pythonpath) are case-insensitive (converted to lowercase)
+ * conf.set("Default", "pythonpath", "/usr/bin/python3");
+ * ---
+ *
+ * License: 0BSD
+ * Version: 0.2
+ * History:
+ *      0.2 Add .getBool()
+ *      0.1 Initial release
+ */
+module mlib.configparser;
+
+private
+{
+    import std.conv : ConvException;
+    import std.stdio : File;
+}
+
+public class DuplicateSectionException : Exception
+{
+    private string m_section;
+
+    this(string section)
+    {
+        string msg = "Section " ~ section ~ " already exists.";
+        m_section = section;
+        super(msg);
+    }
+
+    string section()
+    {
+        return m_section;
+    }
+}
+
+public class NoSectionException : Exception
+{
+    private string m_section;
+
+    this(string section)
+    {
+        string msg = "Section '" ~ section ~ "' does not exist.";
+        m_section = section;
+        super(msg);
+    }
+
+    string section()
+    {
+        return m_section;
+    }
+}
+
+public class NoOptionException : Exception
+{
+    private string m_section;
+    private string m_option;
+
+    this(string section, string option)
+    {
+        string msg = "Section '" ~ section ~ "' does not have option '" ~
+            option ~ "'.";
+        m_section = section;
+        m_option = option;
+        super(msg);
+    }
+
+    string section() { return m_section; }
+    string option() { return m_option; }
+}
+
+/**
+ * The main configuration parser.
+ */
+public class ConfigParser
+{
+    private char[] m_delimiters;
+    private char[] m_commentPrefixes;
+
+    /** current section for parsing */
+    private string m_currentSection;
+    private string[string][string] m_sections;
+
+    /**
+     * Creates a new instance of ConfigParser.
+     */
+    this(char[] delimiters = ['=', ':'], char[] commentPrefixes = ['#', ';'])
+    {
+        m_delimiters = delimiters;
+        m_commentPrefixes = commentPrefixes;
+    }
+
+    /**
+     * Return an array containing the available sections.
+     */
+    string[] sections()
+    {
+        return m_sections.keys();
+    }
+
+    ///
+    unittest
+    {
+        auto conf = new ConfigParser();
+
+        assert(0 == conf.sections().length);
+
+        conf.addSection("Section");
+
+        assert(1 == conf.sections().length);
+    }
+
+    /**
+     * Add a section named `section` to the instance.
+     *
+     * Throws:
+     *   - DuplicateSectionError if a section by the given name already
+     * exists.
+     */
+    void addSection(string section)
+    {
+        if (section in m_sections)
+            throw new DuplicateSectionException(section);
+        m_sections[section] = null;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertNotThrown, assertThrown;
+
+        auto conf = new ConfigParser();
+
+        /* doesn't yet exist */
+        assertNotThrown!DuplicateSectionException(conf.addSection("sample"));
+        /* already exists */
+        assertThrown!DuplicateSectionException(conf.addSection("sample"));
+    }
+
+    /**
+     * Indicates whether the named `section` is present in the configuration.
+     *
+     * Params:
+     *   section = The section to check for in the configuration.
+     *
+     * Returns: `true` if the section exists, `false` otherwise.
+     */
+    bool hasSection(string section)
+    {
+        auto exists = (section in m_sections);
+        return (exists !is null);
+    }
+
+    ///
+    unittest
+    {
+        auto conf = new ConfigParser();
+        conf.addSection("nExt");
+        assert(true == conf.hasSection("nExt"), "Close the world.");
+        assert(false == conf.hasSection("world"), "Open the nExt.");
+    }
+
+    string[] options(string section)
+    {
+        if (false == this.hasSection(section))
+            throw new NoSectionException(section);
+        return m_sections[section].keys();
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertNotThrown, assertThrown;
+
+        auto conf = new ConfigParser();
+
+        conf.addSection("Settings");
+
+        assertNotThrown!NoSectionException(conf.options("Settings"));
+        assertThrown!NoSectionException(conf.options("void"));
+
+        string[] options = conf.options("Settings");
+        assert(0 == options.length, "More keys than we need");
+    }
+
+    bool hasOption(string section, string option)
+    {
+        if (false == this.hasSection(section))
+            return false;
+
+        auto exists = (option in m_sections[section]);
+        return (exists !is null);
+    }
+    /*
+    string[] read(string[] filenames)
+    {
+        return null;
+    }*/
+
+    void read(string filename)
+    {
+        import std.file : FileException, exists, isFile;
+
+        if (false == exists(filename)) {
+            throw new FileException(filename);
+        }
+
+        if (false == isFile(filename)) {
+            throw new FileException(filename);
+        }
+
+        File file = File(filename, "r");
+        scope(exit) { file.close(); }
+        read(file, false);
+    }
+
+    ///
+    unittest
+    {
+        import std.file : remove;
+        import std.stdio : File;
+
+        auto configFile = File("test.conf", "w+");
+        configFile.writeln("[Section 1]");
+        configFile.writeln("key=value");
+        configFile.writeln("\n[Section 2]");
+        configFile.writeln("key2 = value");
+        configFile.close();
+
+        auto conf = new ConfigParser();
+        conf.read("test.conf");
+
+        assert(2 == conf.sections.length, "Incorrect Sections length");
+        assert(true == conf.hasSection("Section 1"),
+               "Config file doesn't have Section 1");
+        assert(true == conf.hasOption("Section 1", "key"),
+               "Config file doesn't have 'key' in 'Section 1'");
+
+        remove("test.conf");
+    }
+
+    /**
+     * Parse a config file.
+     *
+     * Params:
+     *   file = Reference to the file from which to read.
+     *   close = Close the file when finished parsing.
+     */
+    void read(ref File file, bool close = true)
+    {
+        import std.array : array;
+        import std.algorithm.searching : canFind;
+        import std.string : strip;
+
+        scope(exit) { if (close) file.close(); }
+
+        string[] lines = file.byLineCopy.array;
+
+        for (auto i = 0; i < lines.length; i++) {
+            string line = lines[i].strip();
+
+            if (line == "")
+                continue;
+
+            if ('[' == lines[i][0]) {
+                parseSectionHeader(lines[i]);
+            } else if (false == canFind(m_commentPrefixes, lines[i][0])) {
+                parseLine(lines[i]);
+            }
+            /* ignore comments */
+        }
+    }
+
+    // void readString(string str)
+    // {
+    // }
+
+    /**
+     * Get an `option` value for the named `section`.
+     *
+     * Params:
+     *   section = The section to look for the given `option`.
+     *   option = The option to return the value of
+     *   fallback = Fallback value if the `option` is not found. Can be null.
+     *
+     * Returns:
+     *   - The value for `option` if it is found.
+     *   - `null` if the `option` is not found and `fallback` is not provided.
+     *   - `fallback` if the `option` is not found and `fallback` is provided.
+     *
+     * Throws:
+     *   - NoSectionException if the `section` does not exist and no fallback is provided.
+     *   - NoOptionException if the `option` does not exist and no fallback is provided.
+     */
+    string get(string section, string option)
+    {
+        if (false == this.hasSection(section))
+            throw new NoSectionException(section);
+
+        if (false == this.hasOption(section, option))
+            throw new NoOptionException(section, option);
+
+        return m_sections[section][option];
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+        conf.addSection("Section");
+        conf.set("Section", "option", "value");
+
+        assert(conf.get("Section", "option") == "value");
+        assertThrown!NoSectionException(conf.get("section", "option"));
+        assertThrown!NoOptionException(conf.get("Section", "void"));
+    }
+
+    /// Ditto
+    string get(string section, string option, string fallback)
+    {
+        string res = fallback;
+
+        try {
+            res = get(section, option);
+        } catch (NoSectionException e) {
+            return res;
+        } catch (NoOptionException e) {
+            return res;
+        }
+
+        return res;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+        conf.addSection("Section");
+        conf.set("Section", "option", "value");
+
+        assert("value" == conf.get("Section", "option"));
+        assert("fallback" == conf.get("section", "option", "fallback"));
+        assert("fallback" == conf.get("Section", "void", "fallback"));
+
+        /* can use null for fallback */
+        assert(null == conf.get("section", "option", null));
+        assert(null == conf.get("Section", "void", null));
+    }
+
+    /**
+     * A convenience method which casts the value of `option` in `section`
+     * to an integer.
+     *
+     * Params:
+     *   section = The section to look for the given `option`.
+     *   option = The option to return the value for.
+     *   fallback = The fallback value to use if `option` isn't found.
+     *
+     * Returns:
+     *
+     *
+     * Throws:
+     *   - NoSectionFoundException if `section` doesn't exist.
+     *   - NoOptionFoundException if the `section` doesn't contain `option`.
+     *   - ConvException if it failed to parse the value to an int.
+     *   - ConvOverflowException if the value would overflow an int.
+     *
+     * See_Also: get()
+     */
+    int getInt(string section, string option)
+    {
+        import std.conv : parse;
+
+        string res;
+
+        res = get(section, option);
+
+        return parse!int(res);
+    }
+
+    /// Ditto
+    int getInt(string section, string option, int fallback)
+    {
+        int res = fallback;
+
+        try {
+            res = getInt(section, option);
+        } catch (Exception e) {
+            return res;
+        }
+
+        return res;
+    }
+
+    /*
+    double getDouble(string section, string option)
+    {
+    }
+
+    double getDouble(string section, string option, double fallback)
+    {
+    }
+
+    float getFloat(string section, string option)
+    {
+    }
+
+    float getFloat(string section, string option, float fallback)
+    {
+    }*/
+
+    /**
+     * A convenience method which coerces the $(I option) in the
+     * specified $(I section) to a boolean value.
+     * 
+     * Note that the accepted values for the option are "1", "yes",
+     * "true", and "on", which cause this method to return `true`, and
+     * "0", "no", "false", and "off", which cause it to return `false`.
+     * 
+     * These string values are checked in a case-insensitive manner.
+     * 
+     * Params:
+     *   section = The section to look for the given option.
+     *   option = The option to return the value for.
+     *   fallback = The fallback value to use if the option was not found.
+     * 
+     * Throws:
+     *   - NoSectionFoundException if `section` doesn't exist.
+     *   - NoOptionFoundException if the `section` doesn't contain `option`.
+     *   - ConvException if any other value was found.
+     */
+    bool getBool(string section, string option)
+    {
+        import std.string : toLower;
+
+        string value = get(section, option);
+        
+        switch (value.toLower)
+        {
+        case "1":
+        case "yes":
+        case "true":
+        case "on":
+            return true;
+        case "0":
+        case "no":
+        case "false":
+        case "off":
+            return false;
+        default:
+            throw new ConvException("No valid boolean value found");
+        }
+    }
+
+    /// Ditto
+    bool getBool(string section, string option, bool fallback)
+    {
+        try {
+            return getBool(section, option);
+        } catch (Exception e) {
+            return fallback;
+        }
+    }
+
+    /*
+    string[string] items(string section)
+    {
+    }*/
+
+    /**
+     * Remove the specified `option` from the specified `section`.
+     *
+     * Params:
+     *   section = The section to remove from.
+     *   option = The option to remove from section.
+     *
+     * Retruns:
+     *   `true` if option existed, false otherwise.
+     *
+     * Throws:
+     *  - NoSectionException if the specified section doesn't exist.
+     */
+    bool removeOption(string section, string option)
+    {
+        if ((section in m_sections) is null) {
+            throw new NoSectionException(section);
+        }
+
+        if (option in m_sections[section]) {
+            m_sections[section].remove(option);
+            return true;
+        }
+
+        return false;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+        conf.addSection("Default");
+        conf.set("Default", "exists", "true");
+
+        assertThrown!NoSectionException(conf.removeOption("void", "false"));
+        assert(false == conf.removeOption("Default", "void"));
+        assert(true == conf.removeOption("Default", "exists"));
+    }
+
+    /**
+     * Remove the specified `section` from the config.
+     *
+     * Params:
+     *   section = The section to remove.
+     *
+     * Returns:
+     *   `true` if the section existed, `false` otherwise.
+     */
+    bool removeSection(string section)
+    {
+        if (section in m_sections) {
+            m_sections.remove(section);
+            return true;
+        }
+        return false;
+    }
+
+    ///
+    unittest
+    {
+        auto conf = new ConfigParser();
+        conf.addSection("Exists");
+        assert(false == conf.removeSection("DoesNotExist"));
+        assert(true == conf.removeSection("Exists"));
+    }
+
+    void set(string section, string option, string value)
+    {
+        if (false == this.hasSection(section))
+            throw new NoSectionException(section);
+
+        m_sections[section][option] = value;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+
+        assertThrown!NoSectionException(conf.set("Section", "option",
+            "value"));
+
+        conf.addSection("Section");
+        conf.set("Section", "option", "value");
+        assert(conf.get("Section", "option") == "value");
+    }
+
+    // void write(ref File file)
+    // {
+    // }
+
+  private:
+
+    void parseSectionHeader(ref string line)
+    {
+        import std.array : appender, assocArray;
+
+        auto sectionHeader = appender!string;
+        /* presume that the last character is ] */
+        sectionHeader.reserve(line.length - 1);
+        string popped = line[1 .. $];
+
+        foreach(c; popped) {
+            if (c != ']')
+                sectionHeader.put(c);
+            else
+                break;
+        }
+
+        version (DigitalMars) {
+            m_currentSection = sectionHeader[];
+        } else {
+            /* LDC / GNU */
+            m_currentSection = sectionHeader.data;
+        }
+
+        try {
+            this.addSection(m_currentSection);
+        } catch (DuplicateSectionException e) {
+            /* haven't checked what python would do */
+            /* perhaps we should just merge the settings? */
+            return;
+        }
+    }
+
+    void parseLine(ref string line)
+    {
+      import std.string : indexOfAny, strip;
+
+        ptrdiff_t idx = line.indexOfAny(m_delimiters);
+        if (-1 == idx) return;
+        string option = line[0 .. idx].dup.strip;
+        string value = line[idx + 1 .. $].dup.strip;
+
+        m_sections[m_currentSection][option] = value;
+    }
+}

diff -r 000000000000 -r 019d96c167ce mlib/directories.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mlib/directories.d	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,317 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+ * software, either in source code form or as a compiled binary, for any purpose,
+ * commercial or non-commercial, and by any means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors of this
+ * software dedicate any and all copyright interest in the software to the public
+ * domain. We make this dedication for the benefit of the public at large and to
+ * the detriment of our heirs and successors.  We intend this dedication to be an
+ * overt act of relinquishment in perpetuity of all present and future rights to
+ * this software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * This module provides quick & easy access to the XDG folder locations on GNU/Linux.  Currently,
+ * only POSIX (XDG Base Directory Specification) is supported.  OS X (Standard Directories) and
+ * Windows (Known Folder) will be supported at a later date.
+ *
+ * The main goal of this module is to provide a minimal and simple API.
+ *
+ * API
+ * ---
+ * enum Directory
+ *   {
+ *    home,
+ *    config,
+ *    data,
+ *    cache,
+ *   }
+ *
+ * DirEntry open(Directory);
+ * ---
+ *
+ * This module supports D version greater than or equal to 2.068.0.
+ *
+ * Authors: mio <[e-mail]>
+ * Bugs: Doesn't check if the environment variable value is empty.
+ * Date: June 12, 2021
+ * License: public domain
+ * Standards: XDG Base Directory Specification 0.8
+ * Version: 0.X.X
+ */
+module mlib.directories;
+
+import std.file : DirEntry;
+
+public enum Directory
+  {
+   home,
+   data,
+   config,
+   state,
+   //   dataDirs,   /* XDG */
+   //   configDirs, /* XDG */
+   cache,
+   runtime,
+  }
+
+/++
+ Return a DirEntry pointing to `dt`.
+ 
+ If the folder couldn't be found, an empty DirEntry is returned.
+ 
+ Examples:
+ ----
+ import directories;
+ import std.stdio;
+
+ int main()
+ {
+   DirEntry userConfDir = open(Directory.config);
+   /* Handle error */
+   if (0 == userConfDir.name.length)
+     {
+       stderr.writeln("Failed to find user config directory.");
+       return 1;
+     }
+   writefln("User config directory is %s", userConfDir.name);
+   return 0;
+ }
+ ----
++/
+public DirEntry open(Directory dt) nothrow// @safe
+{
+  /* 
+   * Posix covers a few operating systems, if yours has a alternate
+   * structure that is preferred over XDG, let me know.
+   */
+  version (Posix) enum supported = true;
+  else enum supported = false;
+  /* More operating systems will be supported soon-ish. */
+
+  static if (false == supported)
+    {
+      import core.stdc.stdio : fprintf, stderr;
+
+      fprintf(stderr, "*** error: The operating system you're running isn't supported. ***\n");
+      // TODO: webpage for general contribution guide reporting.
+      assert(false, "Unsupported platform.");
+    }
+
+  immutable string path = getPath(dt);
+  if (path is null) return DirEntry();
+  try {
+    return DirEntry(path);
+  } catch (Exception e) {
+    return DirEntry();
+  }
+}
+
+///
+unittest
+{
+  import std.process : environment;
+  import std.path : buildPath;
+
+  /*
+   * Environment Variables (for checking against)
+   * Currently only tests on Posix since that's the only supported
+   * platform.
+   */
+  immutable string homeE = environment.get("HOME");
+  immutable string configE = environment.get("XDG_CONFIG_HOME",
+					     buildPath(homeE, ".config"));
+  immutable string dataE = environment.get("XDG_DATA_HOME",
+					   buildPath(homeE, ".local", "share"));
+  immutable string cacheE = environment.get("XDG_CACHE_HOME",
+					    buildPath(homeE, ".cache"));
+
+  // Compare against folders.d (note that folders is cross-platform, so
+  // some errors may occur on non-POSIX)
+  assert(homeE == open(Directory.home));
+  assert(configE == open(Directory.config));
+  assert(dataE == open(Directory.data));
+  assert(cacheE == open(Directory.cache));
+  import std.stdio;
+  writeln(typeof(open(Directory.cache)).stringof);
+}
+
+private:
+
+void errLog(string msg) nothrow @trusted
+{
+  import core.stdc.stdio : fprintf, stderr;
+  
+  // TODO: webpage for general issue reporting.
+  // fprintf(stderr, "**  info: report bugs to https://yume-neru.neocities.org/bugs.html **\n");
+  fprintf(stderr, "*** error: %s ***\n", msg.ptr);
+}
+
+immutable(string) getPath(in Directory dt) nothrow @safe
+{
+  switch (dt)
+    {
+    case Directory.home:
+      return home();
+    case Directory.data:
+      return data();
+    case Directory.config:
+      return config();
+    case Directory.cache:
+      return cache();
+    default:
+      assert(false, "Unsupported Directory");
+    }
+}
+
+immutable(string) home() nothrow @trusted
+{
+  import std.path : isAbsolute;
+  import std.process : environment;
+    
+  string homeE;
+    
+  try {
+    homeE = environment.get("HOME");
+  } catch (Exception e) {
+    homeE = null;
+  }
+    
+  if (homeE is null) {
+    import std.string : fromStringz;
+    const(char)* pwdHome = fallbackHome();
+    if (pwdHome !is null)
+      homeE = cast(string)(pwdHome.fromStringz).dup;
+    if (false == homeE.isAbsolute)
+      homeE = null;
+  }
+  return homeE;
+}
+
+immutable(string) data() nothrow @safe
+{
+  import std.path : buildPath, isAbsolute;
+  import std.process : environment;
+
+  string dataE;
+
+  try {
+    dataE = environment.get("XDG_DATA_HOME");
+  } catch (Exception e) {
+    dataE = null;
+  }
+
+  if (dataE is null || false == dataE.isAbsolute)
+    dataE = buildPath(home(), ".local", "share");
+
+  return dataE;
+}
+
+immutable(string) config() nothrow @safe
+{
+  import std.path : buildPath, isAbsolute;
+  import std.process : environment;
+    
+  string configE;
+    
+  try {
+    configE = environment.get("XDG_CONFIG_HOME");
+  } catch (Exception e) {
+    configE = null;
+  }
+    
+  if (configE is null || false == configE.isAbsolute)
+    configE = buildPath(home(), ".config");
+
+  return configE;
+}
+
+/* TODO: xdgState() nothrow @safe */
+
+immutable(string) cache() nothrow @safe
+{
+  import std.path : buildPath, isAbsolute;
+  import std.process : environment;
+
+  string cacheE;
+
+  try {
+    cacheE = environment.get("XDG_CACHE_HOME");
+  } catch (Exception e) {
+    cacheE = null;
+  }
+
+  if (cacheE is null || false == cacheE.isAbsolute)
+    cacheE = buildPath(home(), ".cache");
+
+  return cacheE;
+}
+
+/* Helpers */
+
+const(char)* fallbackHome() nothrow @trusted
+{
+    import core.stdc.string : strdup;
+
+    passwd* pw;
+    char* home;
+
+    setpwent();
+    pw = getpwuid(getuid());
+    endpwent();
+
+    if (pw is null || pw.pw_dir is null)
+        return null;
+
+    home = strdup(pw.pw_dir);
+    return home;
+}
+
+@system @nogc extern(C) nothrow
+{
+    /* <bits/types.h> */
+    alias gid_t = uint;
+    alias uid_t = uint;
+    
+    /* <pwd.h> */
+    struct passwd
+    {
+        /// Username
+        char* pw_name;
+        /// Hashed passphrase, if shadow database is not in use
+        char* pw_password;
+        /// User ID
+        uid_t pw_uid;
+        /// Group ID
+        gid_t pw_gid;
+        /// "Real" name
+        char* pw_gecos;
+        /// Home directory
+        char* pw_dir;
+        /// Shell program
+        char* pw_shell;
+    }
+    
+    /// Rewind the user database stream
+    extern void setpwent();
+    
+    /// Close the user database stream
+    extern void endpwent();
+    
+    /// Retrieve the user database entry for the given user ID
+    extern passwd* getpwuid(uid_t uid);
+    
+    /* <unistd.h> */
+    /// Returns the real user ID of the calling process.
+    extern uid_t getuid();
+}

diff -r 000000000000 -r 019d96c167ce mlib/dub.sdl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mlib/dub.sdl	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,5 @@
+name "mlib"
+description "A collection of miscellaneous D files."
+license "public domain"
+
+sourcePaths "."

diff -r 000000000000 -r 019d96c167ce pixiv_remove_unfollowed.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pixiv_remove_unfollowed.d	Fri Jan 06 20:48:18 2023 +1000
@@ -0,0 +1,202 @@
+/**
+ * A simple tool to help identify which pixiv accounts you've
+ * downloaded media from, have since unfollowed, but haven't removed
+ * the directory.
+ * 
+ * Bugs:
+ *  If you encounter any errors, please let me know.
+ *  I don't include any form of automated error reporting,
+ *  so please consider attaching the "pixiv_remove_unfollowed.log"
+ *  file.
+ */
+module app;
+
+import core.stdc.stdlib : exit;
+
+import std.experimental.logger : FileLogger;
+
+import std.container : DList;
+import std.file;
+import std.path;
+import std.stdio;
+import std.string;
+
+import mlib.configparser;
+import mlib.directories;
+
+import pixivd;
+import pixivd.types;
+
+struct Context
+{
+	string phpsessid;
+	string pixivBaseDir;
+}
+
+private FileLogger logger;
+
+// Initialize a Context.
+// Could exit the program if it failed to find the user configuration directory,
+// or if the user doesn't enter a PHPSESSID value when prompted.
+Context fetchContext()
+{
+	Context ctx;
+
+	DirEntry configDir = open(Directory.config);
+	if (configDir.name.length == 0) {
+		logger.critical("directories.d open(Directory.config) failed to return a valid DirEntry.");
+		stderr.writeln("Failed to determine your configuration directory, please consider setting the" ~
+			" XDG_CONFIG_HOME environment variable.");
+		exit(1);
+	}
+
+	auto phpsessidPath = buildPath(configDir.name, "pixivd", "phpsessid.txt");
+	string phpsessid;
+
+	if (false == exists(phpsessidPath)) {
+		mkdirRecurse(buildPath(configDir.name, "pixivd"));
+		writeln("PHPSESSID not found, please enter:");
+		phpsessid = readln().strip();
+		if (phpsessid.empty) {
+			stderr.writeln("No PHPSESSID entered, exiting.");
+			exit(1);
+		}
+		auto f = File(phpsessidPath, "w");
+		f.writeln(phpsessid);
+		f.close();
+
+		ctx.phpsessid = phpsessid;
+		return ctx;
+	} else {
+		auto phpsessidFile = File(phpsessidPath, "r");
+		phpsessid = phpsessidFile.readln().strip();
+
+		if (phpsessid.empty) {
+			writeln("PHPSESSID not found, please enter:");
+			phpsessid = readln().strip();
+			if (phpsessid.empty) {
+				stderr.writeln("No PHPSESSID entered, exiting.");
+				exit(1);
+			}
+			phpsessidFile.writeln(phpsessid);
+		}
+		phpsessidFile.close();
+	}
+
+	ctx.phpsessid = phpsessid;
+	return ctx;
+}
+
+string getPixivPictureDir()
+{
+	auto configDirPath = open(Directory.config);
+	auto configFilePath = buildPath(configDirPath.name, "pixiv_down", "settings.conf");
+
+	if (false == exists(configFilePath)) {
+		logger.warningf("\"%s\" does not exist.", configFilePath);
+		return "";
+	}
+
+	scope configparser = new ConfigParser();
+	configparser.read(configFilePath);
+
+	return configparser.get("output", "base_folder");
+}
+
+DList!string processDirs(string pixivDirPath)
+{
+	import std.ascii : isDigit;
+
+	auto dirs = dirEntries(pixivDirPath, SpanMode.shallow);
+	auto uids = DList!string();
+
+	foreach(dir; dirs) {
+		auto bname = baseName(dir);
+		if (bname.length == 0 || false == isDigit(bname[0])) {
+			continue;
+		}
+		auto uid = bname.split('_')[0];
+		uids.insert(uid);
+	}
+
+	return uids;
+}
+
+void removeUserId(in ref Context ctx, string id) {
+	foreach(dir; dirEntries(ctx.pixivBaseDir, SpanMode.shallow)) {
+		string dirname = baseName(dir.name);
+		if (dirname.startsWith(id)) {
+			rmdirRecurse(dir);
+			writefln("Deleted directory: %s", dirname);
+		}
+	}
+}
+
+void removeUnfollowed(in ref Context ctx, DList!string uids)
+{
+	import core.thread : Thread;
+	import core.time : seconds;
+
+	auto client = new Client(ctx.phpsessid);
+
+	foreach (id; uids) {
+		FullUser user;
+		try {
+			user = client.fetchUser(id);
+		} catch (PixivJSONException pje) {
+			logger.warningf("(PixivJSONException) %s", pje.msg);
+			writefln("User ID %s has either left pixiv, or does not exist.", id);
+			write("Do you want to remove the related directories? [y/N]: ");
+			string input = readln().strip().toLower();
+
+			if (input == "y" || input == "yes") {
+				removeUserId(ctx, id);
+			}
+			continue;
+		} catch (Exception e) {
+			logger.critical(e.msg);
+
+			stderr.writefln("Error encountered fetching user %s. No files were modified.", id);
+			continue;
+		}
+
+		if (false == user.following) {
+			writefln("Found user not followed: %s (%s)", user.userName, user.userId);
+			write("Do you want to remove the related directories? [y/N]: ");
+			string input = readln().strip().toLower();
+
+			if (input == "y" || input == "yes") {
+				writeln("Will remove user data.");
+				removeUserId(ctx, id);
+			}
+		} else {
+			writefln("Found followed user: %s", user.userName);
+		}
+		writeln("Sleeping 10 seconds");
+		Thread.sleep(10.seconds);
+	}
+}
+
+
+int main(string[] args)
+{
+	logger = new FileLogger("pixiv_remove_unfollowed.log");
+
+	Context ctx = fetchContext();
+
+	ctx.pixivBaseDir = getPixivPictureDir();
+	if (0 == ctx.pixivBaseDir.length) {
+		stderr.writeln("Error: Could not retrieve pixiv_down configuration file. " ~
+			"Possibly because pixiv_down hasn't been used before.");
+		return 1;
+	}
+
+	DList!string uids = processDirs(ctx.pixivBaseDir);
+	if (uids.empty) {
+		writefln("No users found in %s!", ctx.pixivBaseDir);
+		return 0;	
+	}
+
+	removeUnfollowed(ctx, uids);
+	return 0;
+}