Exemple #1
0
async def get_bible_verse(reference, mode, version, headings, verse_numbers):
    biblehub_versions = ["BSB", "NHEB", "WBT"]
    bibleserver_versions = ["LUT", "LXX", "SLT", "EU"]
    apibible_versions = ["KJVA"]

    non_bg = biblehub_versions + apibible_versions + bibleserver_versions

    if version not in non_bg:
        result = await biblegateway.get_result(reference, version, headings,
                                               verse_numbers)
        return verseutils.process_result(result, mode, reference, version,
                                         None)
    elif version in apibible_versions:
        result = await apibible.get_result(reference, version, headings,
                                           verse_numbers)
        return verseutils.process_result(result, mode, reference, version,
                                         None)
    elif version in biblehub_versions:
        result = await biblehub.get_result(reference, version, verse_numbers)
        return verseutils.process_result(result, mode, reference, version,
                                         None)
    elif version in bibleserver_versions:
        result = await bibleserver.get_result(reference, version,
                                              verse_numbers)
        return verseutils.process_result(result, mode, reference, version,
                                         None)
Exemple #2
0
    async def process_raw_message(cls, raw_message, sender, lang, guild):
        available_versions = versions.get_versions_by_acronym()
        brackets = formatting.get_guild_brackets(guild)
        msg = raw_message.content
        msg = " ".join(msg.splitlines())

        if brackets is None:
            brackets = central.brackets

        if " " in msg:
            verses = []

            msg = utils.purify(msg.title())

            results = utils.get_books(msg)
            results.sort(key=lambda item: item[
                1])  # sort the results based on the index that they were found

            for book, index in results:
                verse = utils.create_verse_object(book, index, msg,
                                                  available_versions, brackets)

                if verse != "invalid" and verse is not None:
                    skip = False

                    for key, val in verse.items():
                        if key is "book" or key is "chapter":
                            if val is None or val == "None":
                                skip = True

                    if not skip:
                        verses.append(verse)

            if len(verses) > 6:
                responses = [
                    "spamming me, really?", "no spam pls", "be nice to me",
                    "such verses, many spam", "\(º □ º l|l)/ SO MANY VERSES",
                    "don't spam me, i'm a good bot",
                    "hey buddy, get your own bot to spam",
                    "i'm a little robot, short and stout\n"
                    "stop spamming me or i'll claw your eyes out!"
                ]

                random_index = int(math.floor(random.random() *
                                              len(responses)))
                return [{"spam": responses[random_index]}]

            references = []

            for _, verse in enumerate(verses):
                reference = utils.create_reference_string(verse)

                if reference is not None:
                    references.append(reference)

            return_list = []

            for reference in references:
                version = versions.get_version(sender)
                mode = formatting.get_mode(sender)
                headings = formatting.get_headings(sender)
                verse_numbers = formatting.get_verse_numbers(sender)

                ref_split = reference.split(" | v: ")

                if len(ref_split) == 2:
                    reference = ref_split[0]
                    version = ref_split[1]

                if version is None or version == "REV":
                    version = versions.get_guild_version(guild)

                    if version is None or version == "REV":
                        version = "RSV"

                ideal_version = tinydb.Query()
                results = central.versionDB.search(
                    ideal_version.abbv == version)

                if len(results) > 0:
                    for verse in verses:
                        for section in ["ot", "nt", "deu"]:
                            support = utils.check_section_support(
                                results[0], verse, reference, section, lang)

                            if "ok" not in support.keys():
                                return [support]

                    biblehub_versions = ["BSB", "NHEB", "WBT"]
                    # bibleserver_versions = ["LUT", "LXX", "SLT", "EU"]
                    apibible_versions = ["KJVA"]

                    non_bible_gateway = biblehub_versions + apibible_versions  # + bibleserver_versions

                    if version not in non_bible_gateway:
                        result = await biblegateway.get_result(
                            reference, version, headings, verse_numbers)
                        return_list.append(
                            utils.process_result(result, mode, reference,
                                                 version, lang))
                    elif version in apibible_versions:
                        result = await apibible.get_result(
                            reference, version, headings, verse_numbers)
                        return_list.append(
                            utils.process_result(result, mode, reference,
                                                 version, lang))
                    elif version in biblehub_versions:
                        result = await biblehub.get_result(
                            reference, version, verse_numbers)
                        return_list.append(
                            utils.process_result(result, mode, reference,
                                                 version, lang))
                    # elif version in bibleserver_versions:
                    #    result = await bibleserver.get_result(reference, version, verse_numbers)
                    #    return_list.append(utils.process_result(result, mode, reference, version, lang))

            return return_list