smog-usage-stats 1.0.0__py3-none-any.whl

smog_usage_stats/IndividualLookup.py

@@ -0,0 +1,134 @@
+import requests
+from typing import Literal
+from Search import Search
+from UsageStatsLookup import BaseStatsSearch
+
+# TODO: Account for rating when gen is current gen to ONLY be 1695, otherwise be 1630
+
+
+# Chaos searches are basically individual pokemon lookups, where one can get deeper analysis
+# such as movesets, held items, EV spreads, etc
+class ChaosSearch(Search):
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for January"],
+        gen: str | int,
+    ) -> None:
+        super().__init__(year, month, gen)
+
+    def search(self, pokemon: str) -> object | None:
+        res = requests.get(self.base)
+        page_object = res.json()["data"]
+        page_object = self.lower_keys(page_object)
+
+        try:
+            lookup = page_object[pokemon.lower()]
+            return lookup
+        except:
+            return None
+
+    # We will be doing this a lot so make it a function.
+    def lower_keys(self, dictionary: dict) -> dict:
+        """
+        Returns a dictionary with all keys lower-cased.
+        """
+        return {k.lower(): v for k, v in dictionary.items()}
+
+
+class BaseChaosSearch(ChaosSearch):
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for January"],
+        gen: str | int,
+        tier: str,
+    ) -> None:
+        super().__init__(year, month, gen)
+        self.tier = tier.lower()
+        self.base = f"https://www.smogon.com/stats/{self.year}-{self.month}/chaos/"
+
+    @property
+    def tier(self) -> str:
+        return self._tier
+
+    @tier.setter
+    def tier(self, value):
+        self._tier = value
+
+    def build_url(self):
+        self.base += f"gen{self.gen}{self.tier}-1500.json"
+
+
+class MonotypeChaosSearch(ChaosSearch):
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for January"],
+        gen: str | int,
+        typing: str,
+    ) -> None:
+        super().__init__(year, month, gen)
+        self.base = (
+            f"https://www.smogon.com/stats/{self.year}-{self.month}/monotype/chaos/"
+        )
+        self.typing = typing.lower()
+
+    @property
+    def typing(self) -> str:
+        return self._typing
+
+    @typing.setter
+    def typing(self, value):
+        self._typing = value
+
+    def build_url(self):
+        self.base += f"gen{self.gen}monotype-mono{self.typing}-1500.json"
+
+
+# this is to search stats individually, but its a bit more involved, a WIP
+class IndividualStatsLookup(BaseStatsSearch):
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for Janu…"],
+        gen: str | int,
+        tier: str,
+        name: str,
+    ) -> None:
+        super().__init__(year, month, gen, tier)
+        self.name = name.lower()
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value.lower()
+
+    def find_individual_usage(self, resmatrix: list[list] = None) -> dict | None:
+        # resmatrix is the resulting 2d array from the self.search() function
+        if not resmatrix:
+            resmatrix = self.search()
+        for m in resmatrix:
+            if m[1] == self.name:
+                return {m[1]: dict(zip(resmatrix[0], m))}
+        print("No result found.")
+        return None
+
+
+if __name__ == "__main__":
+    # search = BaseChaosSearch("2022", "07", 8, "uu")
+    # search.build_url()
+    # result = search.search("SKARMORY")
+    # print(result)
+
+    # monosearch = MonotypeChaosSearch(year=2022, month="11", gen=9, typing="fairy")
+    # monosearch.build_url()
+    # monoresult = monosearch.search("Gardevoir")
+    # print(monoresult)
+
+    indysearch = IndividualStatsLookup(2022, "11", "8", "ou", "scizor")
+    result = indysearch.find_individual_usage()
+    print(result)

smog_usage_stats/SQLInterface.py

@@ -0,0 +1,139 @@
+import os
+import psycopg2
+from dotenv import load_dotenv
+from os.path import dirname as up
+
+try:
+    load_dotenv()
+except:
+    print("No local environment variables found.")
+
+
+_COLUMNS = (
+    "rank",
+    "pokemon",
+    "usage_pct",
+    "raw_usage",
+    "raw_pct",
+    "real",
+    "real_pct",
+    "date",
+    "tier"
+)
+
+
+class SQLInterface:
+    def __init__(
+        self,
+        db_name: str = None,
+        username: str = None,
+        pwd: str = None,
+        host: str = None,
+        port: str = None,
+    ) -> None:
+        self.db_name = db_name
+        self.username = username
+        self.pwd = pwd
+        self.host = host
+        self.port = port
+        self.conn = self.connect(db_name, username, pwd, host, port)
+        # self.cur = self.conn.cursor() if self.conn else None
+
+    def connect(
+        self,
+        database: str = None,
+        user: str = None,
+        password: str = None,
+        host: str = None,
+        port: str = None,
+    ) -> psycopg2.extensions.connection:
+        
+        connection = psycopg2.connect(
+            database=database if database else os.environ.get("LOCAL_DATABASE"),
+            user=user if user else os.environ.get("LOCAL_USER"),
+            password=password if password else os.environ.get("LOCAL_PASS"),
+            host=host if host else os.environ.get("LOCAL_HOST"),
+            port=port if port else os.environ.get("LOCAL_PORT"),
+        )
+
+        if connection:
+            self.conn = connection
+            print("connected")
+        else:
+            raise ConnectionError("No database connection was established. Please check your credentials.")
+        return connection
+
+    def _create_cursor(self) -> psycopg2.extensions.cursor:
+        """
+        If the user hasn't connected manually, no self.conn exists, so we must call it and create the cursor from default values.
+
+        This function is here because its good practice to close the cursor after executing a command. So it is called at the top of a
+        SQL-performing function and closed after it.
+        """
+        if not self.conn:
+            self.conn = self.connect()
+        curr = self.conn.cursor()
+        return curr
+
+    def update_tables(self) -> None:
+        db_names = ("current", "previous", "tma")
+        columns = (
+            "id_ SERIAL PRIMARY KEY,\n"
+            + _COLUMNS[0]
+            + " INTEGER,\n"
+            + _COLUMNS[1]
+            + " VARCHAR(50),\n"
+            + _COLUMNS[2]
+            + " FLOAT,\n"
+            + _COLUMNS[3]
+            + " INTEGER,\n"
+            + _COLUMNS[4]
+            + " FLOAT,\n"
+            + _COLUMNS[5]
+            + " INTEGER,\n"
+            + _COLUMNS[6]
+            + " FLOAT, \n"
+            + _COLUMNS[7]
+            + " VARCHAR(50), \n"
+            + _COLUMNS[8]
+            + " VARCHAR(50)"
+        )
+
+        cursor = self._create_cursor()
+
+        sql_cmd = f"DROP TABLE IF EXISTS {db_names[-1]}; \n"
+        sql_cmd += f"DROP TABLE IF EXISTS {db_names[1]};\n"
+        sql_cmd += f"DROP TABLE IF EXISTS {db_names[0]};\n"
+        sql_cmd += f"CREATE TABLE {db_names[0]} ({columns});\n"
+        sql_cmd += f"CREATE TABLE {db_names[1]} ({columns});\n"
+        sql_cmd += f"CREATE TABLE {db_names[-1]} ({columns});\n"
+
+        cursor.execute(sql_cmd)
+        self.conn.commit()
+        self._close_cursor(cursor)
+        return
+
+    def load_data_to_table(self, target_table: str) -> None:
+        cursor = self._create_cursor()
+
+        target_dir = os.path.abspath(
+            os.path.join(
+                f"{up(up(__file__))}\\data\\", target_table
+            )
+        )
+
+        print(target_dir)
+        for source in os.listdir(target_dir):
+            with open(os.path.join(target_dir, source), "r") as truth:
+                next(truth)
+                cursor.copy_from(truth, target_table, columns=_COLUMNS, sep=",")
+                self.conn.commit()
+        self._close_cursor(cursor)
+
+    def close_connection(self) -> None:
+        """Closes database connection."""
+        self.conn.close()
+
+    def _close_cursor(self, cursor: psycopg2.extensions.cursor) -> None:
+        """Closes cursor."""
+        cursor.close()

smog_usage_stats/Search.py

@@ -0,0 +1,115 @@
+from typing import Literal
+from os.path import dirname as up
+import os
+import shutil
+from datetime import datetime
+import csv
+
+
+# "Mega"-parent searching class. Everything contained within this class will be available,
+# but not necessarily used by child classes.
+class Search:
+    """Parent searcher class.
+
+    ::params:
+    >year (str or int): a string or integer year
+    >month (str): two-digit string month
+    >gen: (str or int): an integer for whichever Pokemon generation is being queried."""
+
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for January"],
+        gen: str | int,
+    ) -> None:
+        self.year = year
+        self.month = month
+        self.date = datetime.strptime(("-".join([str(year), month])), "%Y-%m")
+        self.gen = gen
+        self.base = "https://www.smogon.com/stats/"
+
+    @property
+    def year(self) -> str | int:
+        return self._year
+
+    @property
+    def month(self) -> str:
+        return self._month
+
+    @property
+    def gen(self) -> str:
+        return self._gen
+
+    @gen.setter
+    def gen(self, value):
+        self._gen = value
+
+    @year.setter
+    def year(self, value):
+        self._year = value
+
+    @month.setter
+    def month(self, value):
+        self._month = value
+
+    def _save_output(
+        self,
+        data: list[list],
+        ending: str,
+        pathname: str | os.PathLike = None,
+    ) -> None:
+        if pathname:
+            storage_dir = os.path.join(
+                f"{self.locate_base_data_directory()}/", pathname
+            )
+        else:
+            storage_dir = os.path.join(f"{self.locate_base_data_directory()}/cache")
+
+        if not os.path.exists((storage_dir)):
+            os.mkdir(storage_dir)
+        # make the document
+        filepath = os.path.join(storage_dir, f"{self.year}-{self.month}_{ending}.csv")
+        with open(
+            filepath,
+            "w",
+            newline="",
+        ) as file:
+            csvWriter = csv.writer(file, delimiter=",")
+            csvWriter.writerows(data)
+
+        if os.stat(filepath).st_size < 100:
+            os.remove(filepath)
+            print(f"File {filepath} deleted as it contained no data.")
+
+    def search_and_save(self, pathname: str | os.PathLike = None) -> None:
+        """
+        Searches the smogon stats repo and saves files to system.
+        """
+        data = self.search()
+        if self.ending:
+            ending = self.ending.split("-")[0]
+            self._save_output(data, ending, pathname=pathname)
+        else:
+            print("No data was saved.")
+            return None
+
+    def create_validation_object(self):
+        this = vars(self)
+        validation_object = {k.replace("_", ""): v for k, v in this.items()}
+        return validation_object
+
+    def locate_base_data_directory(self, reference: str | os.PathLike) -> os.PathLike:
+        """"""
+        base_dir = up(up(reference))
+        # set up the cached dir, theres probably a better way to do this but for now it will suffice
+        cache_dir = os.path.join(base_dir, "data")
+        return cache_dir
+
+    @staticmethod
+    def clear_cache() -> None:
+        """Clears cache files if there are any."""
+        base_dir = up(up(__file__))
+        # set up the cached dir, theres probably a better way to do this but for now it will suffice
+        cache_dir = os.path.join(base_dir, "data\\cache")
+        if os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)

smog_usage_stats/Update.py

@@ -0,0 +1,145 @@
+import UsageStatsLookup as StatsSearch
+import IndividualLookup as IndividualSearch
+from SQLInterface import SQLInterface
+from Search import Search
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+import requests
+from bs4 import BeautifulSoup
+
+# param_dict something like
+
+
+# {
+#   branch: 'BaseStats', 'MonoStats', 'BaseChaos', 'MonoChaos"
+#   year, gen, month, tier or typing all as their own fields
+#   isMonotype: True or False
+#   }
+class Updater:
+    @staticmethod
+    def _set_query_object(param_dict: dict) -> Search:
+        """
+        Basically a backend router that returns a Search.<subclass> object
+        """
+        match param_dict["branch"]:
+            case "BaseStats":
+                new_query = StatsSearch.BaseStatsSearch(
+                    year=param_dict["year"],
+                    month=param_dict["month"],
+                    gen=param_dict["gen"],
+                    tier=param_dict["branch_param"],
+                )
+                return new_query
+            case "MonoStats":
+                new_query = StatsSearch.MonotypeStatsSearch(
+                    year=param_dict["year"],
+                    month=param_dict["month"],
+                    gen=param_dict["gen"],
+                    typing=param_dict["branch_param"],
+                )
+            case "BaseChaos":
+                new_query = IndividualSearch.BaseChaosSearch(
+                    year=param_dict["year"],
+                    month=param_dict["month"],
+                    gen=param_dict["gen"],
+                    tier=param_dict["branch_param"],
+                )
+            case "MonoChaos":
+                new_query = IndividualSearch.MonotypeChaosSearch(
+                    year=param_dict["year"],
+                    month=param_dict["month"],
+                    gen=param_dict["gen"],
+                    typing=param_dict["branch_param"],
+                )
+        return new_query
+
+    @staticmethod
+    def _update_database() -> None:
+        """Updates the database with new data."""
+        sqli = SQLInterface()
+        sqli.connect()
+        sqli.update_tables()
+        for i in ("current", "previous", "tma"):
+            sqli.load_data_to_table(i)
+
+        sqli.close_connection()
+        print("Database successfully updated.")
+
+    def update_monthly(self) -> None:
+        """Called on a monthly basis to update the database as new stats are released."""
+        today = datetime.now()
+
+        # realistically, I should only have to need the current data, and then I can
+        # just reshuffle the folders with shutil functions, which I will probably
+        # change to, but I need to get a working amount of data to work with and have
+        # something to fall back on if I somehow delete a bunch of data I cannot get
+        # back.
+        # I kind of already did this in the old version, so I'll just look there and
+        # see how to handle it.
+        date_dict = {
+            "current": today - relativedelta(months=1),
+            "previous": today - relativedelta(months=2),
+            "tma": today - relativedelta(months=3),
+        }
+
+        gens = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
+
+        def get_tiers(date_obj: datetime) -> tuple[str]:
+            """Internal function to get the available tiers to query. Faster than
+            iterating as it reduces the number of tiers by only picking from the
+            available ones. There's definitely a better way to do this which I am
+            going to change to that just uses the anchor tags ending in -1500.txt,
+            but at the moment this is good enough for a solution to work on perfecting.
+
+                Params:
+                date_object (datetime): a datetime object of at least YYYY-MM format
+
+                Returns:
+                tuple[str] -> a tuple of tiers, as string values
+            """
+            year = date_obj.strftime("%Y")
+            month = date_obj.strftime("%m")
+            url = f"https://www.smogon.com/stats/{year}-{month}/"
+
+            r = requests.get(url)
+            soup = BeautifulSoup(r.text, "html.parser")
+            anchors = soup.find_all("a")
+            available_tiers = []
+            for a in anchors[6:]:
+                a = a.text.strip("gen")
+                a = a.split("-")[0]
+                for g in gens:
+                    if a.startswith(g):
+                        a = a[1:]
+                        print(a)
+                available_tiers.append(a)
+            return tuple(set(available_tiers))
+
+        def get_data(date_obj: datetime, table: str, isMonotype: bool = False) -> None:
+            tiers = get_tiers(date_obj)
+            for g in gens:
+                for t in tiers:
+                    print(
+                        date_dict[table].strftime("%Y"),
+                    )
+                    q = self._set_query_object(
+                        {
+                            "year": date_dict[table].strftime("%Y"),
+                            "month": date_dict[table].strftime("%m"),
+                            "gen": g,
+                            "branch_param": t,
+                            "branch": "BaseStats",
+                            "isMonotype": isMonotype,
+                        }
+                    )
+                    print(q.base)
+                    q.search_and_save(pathname=table)
+
+        for k in date_dict.keys():
+            get_data(date_dict[k], k)
+
+        self._update_database()
+
+
+# Updater().update_monthly()
+# Updater._update_database()

smog_usage_stats/UsageStatsLookup.py

@@ -0,0 +1,192 @@
+from typing import Literal
+from Search import Search
+import requests
+from bs4 import BeautifulSoup
+from Validation import Validations
+
+
+class StatsSearch(Search):
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for January"],
+        gen: str | int
+    ) -> None:
+        super().__init__(year, month, gen)
+        self.ending = None
+
+    ### NOT USED IN CHAOS BRANCH SEARCHES ###
+    def _remove_formatting(self, data: list) -> list[list]:
+        # Set the column names first
+        outlist = [
+            [
+                "rank",
+                "pokemon",
+                "usage_pct",
+                "raw_usage",
+                "raw_pct",
+                "real",
+                "real_pct",
+                "date",
+                "tier"
+            ]
+        ]
+        # Remove the formatting from the webpage
+        for line in data:
+            # remove all linebreaks,symbols and make lowercase
+            line = line.strip("\n")
+            line = line.replace("|", ",").replace(" ", "").replace("%", "").lower()
+            if line.startswith(","):
+                # remove leading and trailing commas
+                line = line[1:-1]
+                # turns it from a list of strings toa 2-d array
+                line = line.split(",")
+                line.append(f'{self.year}-{self.month}')
+                if self.tier:
+                    line.append(f'gen{self.gen}{self.tier}')
+                elif self.typing:
+                    line.append(f'mono{self.typing}')
+
+                # add it to the list to be returned
+                outlist.append(line)
+        return outlist
+
+    @staticmethod
+    def _vintage_search(year, month, gen, tier) -> str:
+        r = requests.get(f"https://www.smogon.com/stats/{year}-{month}/")
+        soup = BeautifulSoup(r.text, "html.parser")
+        anchors = soup.find_all("a")
+
+        tiers = tuple(set(a.text.strip(".txt").split("-")[0] for a in anchors[6:]))
+
+        try:
+            if tiers.index(f"gen{gen}{tier}"):
+                return f"gen{gen}{tier}-1500.txt"
+        except ValueError:
+            try:
+                if tiers.index(tier) and tier == (6 | 7):
+                    return f"{tier}-1500.txt"
+            except ValueError:
+                return "Nothing found."
+
+   
+    def search(self) -> list[list]:
+        """
+        Searches the smogon stats repository and returns a list of lists.
+        """
+        # send the request to get the data
+        res = requests.get(self.base)
+        # get the text if there is any (should add a check in here)
+        data = res.text
+        # send each "unit" of information to a list by splitting on linebreaks
+        data = data.split("\n")
+        # truncate to get rid of the non-relevant prefixes and last two lines of styling
+        data = data[5:-2]
+        # remove the formatting
+        data = self._remove_formatting(data)
+
+        return data
+
+
+class BaseStatsSearch(StatsSearch):
+    """>tier (str): string of tier to be queried."""
+
+    __doc__ = Search.__doc__ + __doc__
+
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for Janu…"],
+        gen: str | int,
+        tier: str,
+    ) -> None:
+        super().__init__(year, month, gen)
+        self.tier = tier.lower()
+        self.base += f"{self.year}-{self.month}/"
+        self._build_url()
+
+    @property
+    def tier(self) -> str:
+        return self._tier.lower()
+
+    @tier.setter
+    def tier(self, value):
+        self._tier = value
+
+
+    def _build_url(self):
+        # Rating of 1500 is defined by Smogon as their target of a normal player
+
+        validation_object = self.create_validation_object()
+        validator = Validations(validation_object)
+        # check dates for valid tiers
+        # since for now I am only looking up newer stats for database, it will be fine
+        if validator.validate():
+            if Validations.is_modern_format(validation_object):
+                ending = f"gen{self.gen}{self.tier}-1500.txt"
+                self.ending = ending
+                self.base += ending
+            else:
+                ending = self._vintage_search(
+                    self.year, self.month, self.gen, self.tier
+                )
+                # below can be deleted after validations are done
+                if ending.endswith(".txt"):
+                    self.ending = ending
+                    self.base += ending
+                # else:
+                #     raise Exception('Invalid information supplied, check your parameters.')
+        else:
+            print("Something isn't correct.")
+
+
+class MonotypeStatsSearch(StatsSearch):
+    """>typing (str): string of type to be queried."""
+
+    __doc__ = Search.__doc__ + __doc__
+
+    def __init__(
+        self,
+        year: str | int,
+        month: Literal["Must be a two digit month string eg: '01' for Janu…"],
+        gen: str | int,
+        typing: Literal["Must be string of type, such as 'fighting' or 'psychic'"],
+    ) -> None:
+        super().__init__(year, month, gen)
+        self.typing = typing.lower()
+        self.base += f"{year}-{month}/monotype/"
+        self._build_url
+
+    @property
+    def typing(self) -> str:
+        return self._typing.lower()
+
+    @typing.setter
+    def typing(self, value):
+        self._typing = value
+
+
+    # I could probably combine this and the other into a singular _build_url() that lives in the parent class, but I think this is simpler
+    def _build_url(self):
+        # Rating of 1500 is defined by Smogon as their target of a normal player
+
+        validation_object = self.create_validation_object()
+        validator = Validations(validation_object)
+        # check dates for valid tiers
+        # since for now I am only looking up newer stats for database, it will be fine
+        if validator.validate(isMonotype=True):
+            ending = f"/gen{self.gen}monotype-mono{self.typing}-1500.txt"
+            self.ending = ending
+            self.base += ending
+        else:
+            print("Something isn't correct.")
+
+
+if __name__ == "__main__":
+    search = BaseStatsSearch(2015, "09", 4, "ou")
+    # query = search.search()
+    # search._save_output(query)
+    search.search_and_save(pathname="current")
+    # search.clear_cache()
+
+    pass

smog_usage_stats/Validation.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+
+types = [
+    "normal",
+    " fire",
+    " water",
+    " grass",
+    " flying",
+    " fighting",
+    " poison",
+    " electric",
+    " ground",
+    " rock",
+    " psychic",
+    " ice",
+    " bug",
+    " ghost",
+    " steel",
+    " dragon",
+    " dark",
+    " fairy",
+]
+
+
+class Validations:
+    def __init__(self, validation_object: dict) -> None:
+        self.validation_object = validation_object
+
+    def validate(self, isMonotype: bool = False) -> bool:
+        """
+        Runs the validation checks, if any of them return False, this also returns False.
+        """
+        if isMonotype:
+            if self.typing not in types:
+                return False
+            if not (self._is_valid_date(self.validation_object)):
+                return False
+        else:
+            if not (self._is_correct_gen(self.validation_object)):
+                print("Generation choice is invalid")
+                return False
+            if not (self._is_valid_date(self.validation_object)):
+                print("Date and generation combination is invalid.")
+                return False
+        return True
+
+    @staticmethod
+    def is_modern_format(validation_object: dict) -> bool:
+        """Checks if the date submitted uses the old non-standardized labeling or not. Anything before Jul 2017 uses non-standard."""
+        if (int(validation_object["date"].year) == 2017) and (
+            int(validation_object["date"].month) <= 6
+        ):
+            return False
+        elif int(validation_object["date"].year) < 2017:
+            return False
+        return True
+
+    @staticmethod
+    def _is_correct_gen(validation_object: dict) -> bool:
+        """Checks if the generation is valid for the date submitted."""
+        cutoff_dates = {
+            "7": datetime.strptime("2016-11", "%Y-%m"),
+            "8": datetime.strptime("2020-11", "%Y-%m"),
+            "9": datetime.strptime("2022-11", "%Y-%m"),
+        }
+        # something like having an object of dates this is where it makes sense to
+        # have dt objects rather than strings
+        # if they fail, return false.
+
+        if int(validation_object["gen"]) <= 6:
+            return True
+        elif (int(validation_object["gen"]) > 6) and (
+            validation_object["date"] < cutoff_dates[str(validation_object["gen"])]
+        ):
+            return False
+        else:
+            return True
+
+    @staticmethod
+    def _is_valid_date(validation_object: dict) -> bool:
+        """Makes sure theres no date submitted before Nov 2014, as there is no data available before then."""
+        year = int(validation_object["date"].year)
+        month = int(validation_object["date"].month)
+
+        if year < 2014:
+            return False
+        elif year == 2014:
+            if month != (11 | 12):
+                return False
+        else:
+            return True

smog_usage_stats/__init__.py

@@ -0,0 +1,11 @@
+import sys
+import os
+
+__version__ = "1.0.0"
+__author__ = "Alan Nardo"
+
+# Get the parent directory
+parent_dir = os.path.dirname(os.path.realpath(__file__))
+
+# Add the parent directory to sys.path
+sys.path.append(parent_dir)

smog_usage_stats-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alan Nardo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

smog_usage_stats-1.0.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: smog-usage-stats
+Version: 1.0.0
+Author-email: "stu.gotz.dev" <gotz.stu.dev@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2023 Alan Nardo
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        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 OR COPYRIGHT HOLDERS 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.
+Keywords: pokemon,usage,pokemon showdown,smogon
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4
+Requires-Dist: pathlib
+Requires-Dist: psycopg ==3.1.12
+Requires-Dist: psycopg-binary ==3.1.12
+Requires-Dist: psycopg2 ==2.9.5
+Requires-Dist: python-dateutil
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: soupsieve
+Requires-Dist: typing-extensions
+Provides-Extra: dev
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: bumpver ; extra == 'dev'
+Requires-Dist: isort ; extra == 'dev'
+Requires-Dist: pip-tools ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+
+# smog_usage_stats
+
+This is a bit of a pet project of mine that has been in the works for some while and
+seen several iterations.
+
+In short, it pulls usage stats from [smogon.com's stats
+pages](https://smogon.com/stats) and turns them into a usable data. Originally, it
+was a very functional solution, currently I am working to shift it to OOP and once
+that's sorted, ship it as a package so other people can use it.
+
+## Quick Rundown
+
+### Installing:
+
+Because its not a package yet, you will have to download this to somewhere on your
+PC. Just download it the same way you normally copy code repositories from Git. Open
+it in your favourite IDE or text editor and have fun.
+
+### How it all works
+
+`Search.py` is the uber parent searcher class, that all other searcher classes
+inherit from. You shouldn't need to ever call this directly.
+
+The four primary search classes are:
+
+`BaseStatsSearch` -> searches the normal stats directory
+
+`MonotypeStatsSearch` -> searches the monotype stats directory
+
+`BaseChaosSearch` -> searches the chaos data contained within a certain months stats
+data
+
+`MonotypeChaosSearch` -> searches the monotype chaos data contained within a certain
+months stats data
+
+The latter two are more individual searches and there is also a (WIP)
+`IndividualStatsSearch` class which will be used to search for individual usage stats
+data from the Base or Monotype stats search classes.
+
+`Validation.py` handles the validation of query parameters for the queries, making
+sure everything is lined up to actually return data. The first instance of this
+project had a very shotgun-blast approach which was massively ineffective and did not
+account for discrepencies in labeling conventions used by Smogon in their earlier
+days of stats collection. You also should never need to call this directly, it is
+effectively a helper class.
+
+`SQLInterface.py` does what it says on the tin, it allows interacting with a (in
+this case) PostgreSQL database instance. I HIGHLY recomend using a .env file if you
+use this in any way, and add it to your `.gitignore`.
+
+`Update.py` is a class to push new data to the database. The SQL data serves as a
+backend for a full-stack application I am working on as well, so it's probably not
+necessary for this nor `SQLInterface.py` to be used for most cases, but it is there
+if someone maybe wants to make a Mongo interface or anything else.
+
+## Future plans:
+
+- Finish up individual stats search
+- Clean up directory to get rid of old data
+- Test test test
+- Write update function to work as a scheduled task
+
+## Contributing:
+
+If you find a bug, please make
+an issue and then submit a pull request when it's sorted.
+
+If you are interested in just using this on your own, feel free to copy and make
+changes as you like, it's not owned by me, just a fun project. I'll add in licensing
+stuff once I package it up, but it will always be open-source.

smog_usage_stats-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+smog_usage_stats/IndividualLookup.py,sha256=ootatwj8uqOvZKURAxOEpif7UfJNTsAJBYgY911aPQw,4053
+smog_usage_stats/SQLInterface.py,sha256=waRapB6a_kITDsbESjHkblMyNdpM9cEBSfLYASpKgNI,4296
+smog_usage_stats/Search.py,sha256=2rB27QEo3J13IJmRM2hYs3x09aB0eVy3Vvm08pi7KTQ,3621
+smog_usage_stats/Update.py,sha256=oNn8ssKgGyJp3071uGq_9rH1ZltcMXBq-E77EeFAK58,5680
+smog_usage_stats/UsageStatsLookup.py,sha256=wsLvV8cLcZoYrjeDHazZHjHBOINB-v3uTwiAJlnB7ZE,6550
+smog_usage_stats/Validation.py,sha256=-xU0k1jdDqkNlC8RHBp3jw3Pupos_R9GpuNqJJKiIr0,2969
+smog_usage_stats/__init__.py,sha256=ilx4c230MJ9n-Ea7QBBRuYR0oHwZ4AmC4BoJROt1G5M,234
+smog_usage_stats-1.0.0.dist-info/LICENSE,sha256=QeNT41FhSfJaY6-r7ImGGyG2bmNSZGKUCPfRnqqZd4Q,1086
+smog_usage_stats-1.0.0.dist-info/METADATA,sha256=b27vAp3ZV9JI-q1FGvnFQf61gPLvHKu2yfuVsh0pABo,5197
+smog_usage_stats-1.0.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+smog_usage_stats-1.0.0.dist-info/top_level.txt,sha256=7X2lZfrImNekiwdq0QFhDbXKglahGMfN3B0sK7twOCo,17
+smog_usage_stats-1.0.0.dist-info/RECORD,,

smog_usage_stats-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

smog_usage_stats-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smog_usage_stats