Exemple #1
0
    async def _urbandictionary(self, ctx: SlashContext, *, word: str):
        r = requests.get(f"http://www.urbandictionary.com/define.php?term={word}")
        soup = BeautifulSoup(r.content, features="html.parser")

        try:
            definitions = soup.find_all(name="div", attrs={"class": "def-panel"})
        except AttributeError:
            raise UserError(f"Unable to find [{word}] in the Urban Dictionary.")

        del r, soup

        if len(definitions) == 0:
            raise UserError(f"Unable to find [{word}] in the Urban Dictionary.")

        try:
            del definitions[1]  # Word of the day
        except IndexError:
            pass

        results = []
        for definition in definitions:
            results.append(
                self.Definition(
                    lookup_word=definition.contents[1].contents[0].text,
                    meaning=definition.contents[2].text,
                    example=definition.contents[3].text,
                    contributor=definition.contents[4].text,
                )
            )

        pages = []
        for index, result in enumerate(results):
            pages.append(
                build_embed(
                    title=f"Searched for: {result.lookup_word}",
                    description=f"Definition #{index + 1} from Urban Dictionary",
                    fields=[
                        ["Meaning", result.meaning],
                        ["Example", result.example],
                        ["Contributor", result.contributor],
                    ],
                )
            )

        await Paginator(
            bot=ctx.bot,
            ctx=ctx,
            pages=pages,
            useIndexButton=True,
            useSelect=False,
            firstStyle=ButtonStyle.gray,
            nextStyle=ButtonStyle.gray,
            prevStyle=ButtonStyle.gray,
            lastStyle=ButtonStyle.gray,
            indexStyle=ButtonStyle.gray,
        ).run()
Exemple #2
0
    async def _crootbot(self, ctx: SlashContext, year: int, search_name: str):
        print(f"[{datetime.datetime.now().astimezone(tz=TZ)}] ### Crootbot")

        if len(search_name) == 0:
            raise UserError("A player's first and/or last search_name is required.")

        if len(str(year)) == 2:
            year += 2000
        elif len(str(year)) == 1 or len(str(year)) == 3:
            raise UserError("The search year must be two or four digits long.")

        if year > datetime.datetime.now().year + 5:
            raise UserError(
                "The search year must be within five years of the current class."
            )

        if year < 1869:
            raise UserError(
                "The search year must be after the first season of college football--1869."
            )

        await ctx.defer()  # Similar to sending a message with a loading screen to edit later on

        log(f"Searching for [{year} {search_name.capitalize()}]", 1)

        global croot_search
        croot_search = FootballRecruit(year, search_name)

        log(f"Found [{len(croot_search)}] results", 1)

        if len(croot_search) == 1:
            return await final_send_embed_fap_loop(
                ctx=ctx, target_recruit=croot_search[0], bot=self.bot
            )

        result_info = search_result_info(croot_search)
        action_row = create_actionrow(*search_buttons)

        embed = build_embed(
            title=f"Search Results for [{year} {search_name.capitalize()}]",
            fields=[["Search Results", result_info]],
        )

        await ctx.send(embed=embed, components=[action_row])

        log(f"Sent search results for [{year} {search_name.capitalize()}]", 1)
Exemple #3
0
    async def _fap_predict(self, ctx: SlashContext, year: int, search_name: str):
        if len(str(year)) == 2:
            year += 2000

        if year > datetime.datetime.now().year + 5:
            raise UserError(
                "The search year must be within five years of the current class."
            )

        if year < 1869:
            raise UserError(
                "The search year must be after the first season of college football--1869."
            )

        await ctx.defer(hidden=True)

        global fap_search
        fap_search = FootballRecruit(year, search_name)

        if type(fap_search) == commands.UserInputError:
            return await ctx.send(content=fap_search, hidden=True)

        async def send_fap_convo(target_recruit):
            await initiate_fap(
                ctx=ctx, user=ctx.author, recruit=target_recruit, client=ctx.bot
            )

        if len(fap_search) == 1:
            return await send_fap_convo(fap_search[0])

        result_info = search_result_info(fap_search)
        action_row = create_actionrow(*search_buttons)

        embed = build_embed(
            title=f"Search Results for [{year} {search_name.capitalize()}]",
            fields=[["Search Results", result_info]],
        )

        await ctx.send(embed=embed, components=[action_row], hidden=True)
Exemple #4
0
    async def _vote(
        self,
        ctx: SlashContext,
        query: str,
        option_a: str = "UP VOTE",
        option_b: str = "DOWN VOTE",
    ):
        if (option_a is not None and option_b is None) or (
            option_b is not None and option_a is None
        ):
            raise UserError("You must provide both options!")

        option_a = str(option_a).upper()
        option_b = str(option_b).upper()

        but_a = ButtonStyle.green
        but_b = ButtonStyle.red

        key = set_component_key()
        buttons_voting = []

        query = query.capitalize()
        if not query.endswith("?"):
            query += "?"

        if option_a != "UP VOTE" and option_b != "DOWN VOTE":  # Non-standard vote
            but_a = but_b = ButtonStyle.gray

        buttons_voting.append(
            create_button(custom_id=f"{key}_a", label=option_a, style=but_a)
        )
        buttons_voting.append(
            create_button(custom_id=f"{key}_b", label=option_b, style=but_b)
        )

        embed = build_embed(
            title=f"Q: {query}",
            inline=False,
            fields=[
                [buttons_voting[-2]["label"], "0"],
                [buttons_voting[-1]["label"], "0"],
                ["Voters", "_"],
            ],
            footer=key,
        )

        await ctx.send(
            content="", embed=embed, components=[create_actionrow(*buttons_voting)]
        )
Exemple #5
0
    async def _possumdroppings(self, ctx: SlashContext, message: str):
        await ctx.defer()

        if not ctx.channel_id == CHAN_POSSUMS:
            raise UserError(
                f"You can only use this command in [{ctx.guild.get_channel(CHAN_POSSUMS).mention}]"
            )

        await ctx.send("Thinking...", delete_after=0)

        embed = build_embed(
            title="Possum Droppings",
            inline=False,
            thumbnail="https://cdn.discordapp.com/attachments/593984711706279937/875162041818693632/unknown.jpeg",
            footer="Created by a possum",
            fields=[["Droppings", message]],
        )
        await ctx.send(embed=embed)
Exemple #6
0
    async def _weather(
        self, ctx: SlashContext, city: str, state: str, country: str = "US"
    ):
        def shift_utc_tz(dt, shift):
            return dt + timedelta(seconds=shift)

        if not len(state) == 2:
            raise UserError("State input must be the two-digit state code.")

        found = False
        for item in US_STATES:
            if item.get("Code") == state.upper():
                found = True
                break
        if not found:
            raise UserError(
                f"Unable to find the state {state.upper()}. Please try again!"
            )

        weather_url = f"https://api.openweathermap.org/data/2.5/weather?appid={WEATHER_API_KEY}&units=imperial&lang=en&q={city},{state},{country}"
        response = requests.get(weather_url, headers=HEADERS)
        j = json.loads(response.content)

        weather = WeatherResponse(j)
        if weather.cod == "404":
            raise UserError(
                f"Unable to find {city.title()}, {state.upper()}. Try again!"
            )

        temp_str = (
            f"Temperature: {weather.main.temp}℉\n"
            f"Feels Like: {weather.main.feels_like}℉\n"
            f"Humidity: {weather.main.humidity}%\n"
            f"Max: {weather.main.temp_max}℉\n"
            f"Min: {weather.main.temp_min}℉"
        )

        if len(weather.wind) == 2:
            wind_str = (
                f"Speed: {weather.wind.speed} MPH\n" f"Direction: {weather.wind.deg} °"
            )
        elif len(weather.wind) == 3:
            wind_str = (
                f"Speed: {weather.wind.speed} MPH\n"
                f"Gusts: {weather.wind.gust} MPH\n"
                f"Direction: {weather.wind.deg} °"
            )
        else:
            wind_str = f"Speed: {weather.wind.speed} MPH"

        hourly_url = f"https://api.openweathermap.org/data/2.5/onecall?lat={weather.coord.lat}&lon={weather.coord.lon}&appid={WEATHER_API_KEY}&units=imperial"
        response = requests.get(hourly_url, headers=HEADERS)
        j = json.loads(response.content)
        hours = []
        for index, item in enumerate(j["hourly"]):
            hours.append(WeatherHour(item))
            if index == 3:
                break

        hour_temp_str = ""
        hour_wind_str = ""
        for index, hour in enumerate(hours):
            if index < len(hours) - 1:
                hour_temp_str += f"{hour.temp}℉ » "
                hour_wind_str += f"{hour.wind_speed} MPH » "
            else:
                hour_temp_str += f"{hour.temp}℉"
                hour_wind_str += f"{hour.wind_speed} MPH"

        sunrise = shift_utc_tz(weather.sys.sunrise, weather.timezone)
        sunset = shift_utc_tz(weather.sys.sunset, weather.timezone)

        sun_str = (
            f"Sunrise: {sunrise.astimezone(tz=TZ).strftime(DT_OPENWEATHER_UTC)}\n"
            f"Sunset: {sunset.astimezone(tz=TZ).strftime(DT_OPENWEATHER_UTC)}"
        )

        embed = build_embed(
            title=f"Weather conditions for {city.title()}, {state.upper()}",
            description=f"It is currently {weather.weather[0].main} with {weather.weather[0].description}. {city.title()}, {state.upper()} is located at {weather.coord.lat}, {weather.coord.lon}.",
            fields=[
                ["Temperature", temp_str],
                ["Clouds", f"Coverage: {weather.clouds.all}%"],
                ["Wind", wind_str],
                ["Temp Next 4 Hours", hour_temp_str],
                ["Wind Next 4 Hours", hour_wind_str],
                ["Sun", sun_str],
            ],
            inline=False,
            thumbnail=f"https://openweathermap.org/img/wn/{weather.weather[0].icon}@4x.png",
        )

        await ctx.send(embed=embed)
Exemple #7
0
def FootballRecruit(year, name):
    all_team_ids = Process_MySQL(fetch="all", query=sqlTeamIDs)
    name = name.split(" ")

    if len(name) == 1:
        _247_search = f"https://247sports.com/Season/{year}-Football/Recruits.json?&Items=15&Page=1&Player.FirstName={name[0]}"
        first_name = requests.get(url=_247_search, headers=HEADERS)
        first_name = json.loads(first_name.text)

        _247_search = f"https://247sports.com/Season/{year}-Football/Recruits.json?&Items=15&Page=1&Player.LastName={name[0]}"
        last_name = requests.get(url=_247_search, headers=HEADERS)
        last_name = json.loads(last_name.text)

        search_results = first_name + last_name
    elif len(name) == 2:
        _247_search = f"https://247sports.com/Season/{year}-Football/Recruits.json?&Items=15&Page=1&Player.FirstName={name[0]}&Player.LastName={name[1]}"

        search_results = requests.get(url=_247_search, headers=HEADERS)
        search_results = json.loads(search_results.text)
    else:
        raise UserError(f"Error occurred attempting to create 247sports search URL.")

    if not search_results:
        raise UserError(
            f"Unable to find [{name[0] if len(name) <= 1 else name[0] + ' ' + name[1]}] in the [{year}] class. Please try again!"
        )

    search_result_players = []

    for index, search_player in enumerate(search_results):
        cur_player = search_player["Player"]

        reqs = requests.get(url=search_player["Player"]["Url"], headers=HEADERS)
        soup = BeautifulSoup(reqs.content, "html.parser")

        # Put into separate variables for debugging purposes
        # red_shirt
        _247_highlights = cur_player.get("Url") + "Videos/"
        _247_profile = cur_player.get("Url", None)
        bio = cur_player.get("Bio", None)
        cb_experts = get_cb_experts(soup, all_team_ids)
        cb_predictions = get_cb_predictions(soup)
        city = cur_player["Hometown"].get("City", None)
        commitment_date = search_player.get("AnnouncementDate", None)
        committed = reformat_commitment_string(search_player)
        committed_school = get_committed_school(
            all_team_ids, get_team_id(search_player)
        )
        early_enrollee = is_early_enrolee(soup)
        early_signee = is_early_signee(soup)
        height = reformat_height(cur_player.get("Height", None))
        key = cur_player.get("Key", None)
        name = cur_player.get("FullName", None)
        position = cur_player["PrimaryPlayerPosition"].get("Abbreviation", None)
        ranking_all_time = get_all_time_ranking(soup)
        ranking_national = get_national_ranking(cur_player)
        ranking_position = get_position_ranking(cur_player)
        ranking_state = get_state_ranking(cur_player)
        rating_numerical = reformat_composite_rating(cur_player)
        rating_stars = cur_player.get("CompositeStarRating", None)
        recruit_interests = get_recruit_interests(search_player)
        recruit_interests_url = cur_player.get("RecruitInterestsUrl", None)
        school = cur_player["PlayerHighSchool"].get("Name", None)
        school_type = get_school_type(soup)
        scout_evaluation = cur_player.get("ScoutEvaluation", None)
        state = cur_player["Hometown"].get("State", None)
        state_abbr = get_state_abbr(cur_player)
        team_id = get_team_id(search_player)
        thumbnail = get_thumbnail(cur_player)
        twitter = get_twitter_handle(soup)
        walk_on = get_walk_on(soup)
        weight = reformat_weight(cur_player.get("Weight", None))
        year = search_player.get("Year", None)

        search_result_players.append(
            Recruit(
                _247_highlights=_247_highlights,
                _247_profile=_247_profile,
                bio=bio,
                cb_experts=cb_experts,
                cb_predictions=cb_predictions,
                city=city,
                commitment_date=commitment_date,
                committed=committed,
                committed_school=committed_school,
                early_enrollee=early_enrollee,
                early_signee=early_signee,
                height=height,
                key=key,
                name=name,
                position=position,
                ranking_all_time=ranking_all_time,
                ranking_national=ranking_national,
                ranking_position=ranking_position,
                ranking_state=ranking_state,
                rating_numerical=rating_numerical,
                rating_stars=rating_stars,
                recruit_interests=recruit_interests,
                recruit_interests_url=recruit_interests_url,
                # red_shirt=None,
                school=school,
                school_type=school_type,
                scout_evaluation=scout_evaluation,
                state=state,
                state_abbr=state_abbr,
                team_id=team_id,
                thumbnail=thumbnail,
                twitter=twitter,
                walk_on=walk_on,
                weight=weight,
                year=year,
            )
        )

        if index == CROOT_SEARCH_LIMIT - 1:
            break

    return search_result_players
Exemple #8
0
    async def _remindme(
        self,
        ctx: SlashContext,
        remind_when: str,
        message: str,
        who: discord.member = None,
        channel: discord.TextChannel = None,
    ):
        if who and channel:
            raise UserError(
                "You cannot input both a member and channel to remind.")
        elif who and not ctx.author == who:
            raise UserError(
                "You cannot set reminders for anyone other than yourself!")
        elif channel in CHAN_BANNED:
            raise ValueError(
                f"Setting reminders in {channel.mention} is banned!")

        await ctx.defer()

        today = datetime.today()

        def convert_dt_value(dt_item: str, from_when: str):

            if dt_item in from_when:
                raw = from_when.split(dt_item)[0]
                if raw.isnumeric():
                    return int(raw)
                else:
                    try:
                        findall = re.findall(r"\D", raw)[-1]
                        return int(raw[raw.find(findall) + 1:])
                    except:
                        return 0
            else:
                return 0

        days = convert_dt_value(DateTimeStrings.day, remind_when)
        hours = convert_dt_value(DateTimeStrings.hour, remind_when)
        minutes = convert_dt_value(DateTimeStrings.minute, remind_when)
        seconds = convert_dt_value(DateTimeStrings.seconds, remind_when)

        time_diff = timedelta(days=days,
                              hours=hours,
                              minutes=minutes,
                              seconds=seconds)

        min_timer_allowed = 5  # 60 * 5

        if time_diff.total_seconds() < min_timer_allowed:
            raise UserError(
                f"The num_seconds entered is too short! The minimum allowed timer is {min_timer_allowed} seconds."
            )

        try:
            raw_when = today + time_diff
        except ValueError:
            raise UserError("The num_seconds entered is too large!")

        duration = raw_when - today
        send_when = today + duration
        mysql_author = f"{ctx.author.name}#{ctx.author.discriminator}"
        is_open = 1

        if who:
            destination = who
        elif channel:
            destination = channel
        else:
            destination = ctx.channel

        try:
            Process_MySQL(
                sqlRecordTasks,
                values=(
                    str(destination.id),
                    message,
                    str(send_when),
                    is_open,
                    mysql_author,
                ),
            )
            destination = ctx.channel
        except:
            raise CommandError("Error submitting MySQL")

        nest_asyncio.apply()
        asyncio.create_task(
            send_reminder(
                num_seconds=duration.total_seconds(),
                destination=destination,
                message=message,
                source=ctx.author,
                alert_when=str(send_when),
            ))

        embed = build_embed(
            title="Bot Frost Reminders",
            description=
            f"Setting a timer for [{destination.mention}] in [{pretty_time_delta(duration.total_seconds())}]. The timer will go off at [{send_when.strftime('%x %X')}].",
            inline=False,
            fields=[["Author", ctx.author.mention], ["Message", message]],
        )
        await ctx.send(embed=embed)