opengamedata-api-utils 1.0.0__tar.gz

opengamedata_api_utils-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 opengamedata
+
+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.

opengamedata_api_utils-1.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: opengamedata-api-utils
+Version: 1.0.0
+Summary: Package of utilities for server-side scripts in OpenGameData.
+Author: Ryan Wilkinson, Glenn Palmer, Daus Husaini
+Author-email: Luke Swanson <superscription58@gmail.com>
+Project-URL: Homepage, https://github.com/opengamedata/opengamedata-api-utils
+Project-URL: Bug Tracker, https://github.com/opengamedata/opengamedata-api-utils/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# opengamedata-server
+
+Repository for server-side scripts in opengamedata. In particular, this is where we have code for the OGD APIs.
+
+## Getting Started
+
+### Hello World of Flask
+
+Steps to run:
+1. Check out latest `opengamedata-server`.
+2. Run `pip install -r requirements.txt` to ensure you've got flask.
+3. Run `flask run`.
+4. Open localhost:5000 or localhost:5000/hello to see some really basic text output from the Flask server.
+
+If Flask doesn't run, it's possible you'd need to first export FLASK_APP as an environment variable, set to "wsgi" (so in Bash, export FLASK_APP=wsgi).
+However, the script is named wsgi.py specifically because Flask is supposed to auto-detect it. So if this issue ever did come up, please ping Luke so he can look into it.
+
+## APIs
+
+Below is a listing of the current API calls available, in function format to indicate what the request parameters.
+For each API, there is also an api path, with path parameters in angle bracket (<, >) format.
+Lastly, at this point in time, the `<server_path>` is `https://fieldday-web.wcer.wisc.edu/opengamedata.wsgi`
+
+### Classroom API
+
+### Dashboard API
+
+### Hello API
+
+#### Verify the API is alive
+
+`<server_path>/hello`  
+`GET()`
+
+- returns no value, and a success message  
+
+`POST()`
+
+- returns no value, and a success message
+
+`PUT()`
+
+- returns no value, and a success message
+
+
+### Player API
+
+### Generate and save players
+
+`<server_path>/player`  
+`GET()`
+
+- returns an unused, randomized player name, or a null value and error message  
+
+`PUT(str player_id, str name = None)`
+
+- Returns no value, and either a success or error message  
+---

opengamedata_api_utils-1.0.0/README.md

@@ -0,0 +1,58 @@
+# opengamedata-server
+
+Repository for server-side scripts in opengamedata. In particular, this is where we have code for the OGD APIs.
+
+## Getting Started
+
+### Hello World of Flask
+
+Steps to run:
+1. Check out latest `opengamedata-server`.
+2. Run `pip install -r requirements.txt` to ensure you've got flask.
+3. Run `flask run`.
+4. Open localhost:5000 or localhost:5000/hello to see some really basic text output from the Flask server.
+
+If Flask doesn't run, it's possible you'd need to first export FLASK_APP as an environment variable, set to "wsgi" (so in Bash, export FLASK_APP=wsgi).
+However, the script is named wsgi.py specifically because Flask is supposed to auto-detect it. So if this issue ever did come up, please ping Luke so he can look into it.
+
+## APIs
+
+Below is a listing of the current API calls available, in function format to indicate what the request parameters.
+For each API, there is also an api path, with path parameters in angle bracket (<, >) format.
+Lastly, at this point in time, the `<server_path>` is `https://fieldday-web.wcer.wisc.edu/opengamedata.wsgi`
+
+### Classroom API
+
+### Dashboard API
+
+### Hello API
+
+#### Verify the API is alive
+
+`<server_path>/hello`  
+`GET()`
+
+- returns no value, and a success message  
+
+`POST()`
+
+- returns no value, and a success message
+
+`PUT()`
+
+- returns no value, and a success message
+
+
+### Player API
+
+### Generate and save players
+
+`<server_path>/player`  
+`GET()`
+
+- returns an unused, randomized player name, or a null value and error message  
+
+`PUT(str player_id, str name = None)`
+
+- Returns no value, and either a success or error message  
+---

opengamedata_api_utils-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools >= 61.0", "wheel", "setuptools-git-versioning >= 1.13"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools-git-versioning]
+enabled = true
+
+[project]
+name = "opengamedata-api-utils"
+dynamic = ["version"]
+authors = [
+   { name="Luke Swanson", email="superscription58@gmail.com" },
+   { name="Ryan Wilkinson" },
+   { name="Glenn Palmer" },
+   { name="Daus Husaini" }
+]
+description = "Package of utilities for server-side scripts in OpenGameData."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/opengamedata/opengamedata-api-utils"
+"Bug Tracker" = "https://github.com/opengamedata/opengamedata-api-utils/issues"

opengamedata_api_utils-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

opengamedata_api_utils-1.0.0/src/ogd/apis/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+	"config",
+	"utils",
+	"schemas"
+]
+
+from . import config
+from . import utils
+from . import schemas

opengamedata_api_utils-1.0.0/src/ogd/apis/schemas/ServerConfigSchema.py

@@ -0,0 +1,148 @@
+"""
+ServerConfigSchema
+
+Contains a Schema class for managing config data for server configurations.
+"""
+
+# import standard libraries
+import logging
+from pathlib import Path
+from typing import Any, Dict, List
+
+# import 3rd-party libraries
+
+# import OGD libraries
+from ogd.core.schemas.Schema import Schema
+from ogd.core.schemas.configs.data_sources.MySQLSourceSchema import MySQLSchema
+
+# import local files
+
+class ServerConfigSchema(Schema):
+    def __init__(self, name:str, all_elements:Dict[str, Any], logger:logging.Logger):
+        self._state_dbs        : Dict[str, MySQLSchema]
+        self._ogd_core         : Path
+        self._google_client_id : str
+        self._dbg_level        : int
+        self._version          : int
+
+        if "DB_CONFIG" in all_elements.keys():
+            self._data_src = ServerConfigSchema._parseDataSources(all_elements["DB_CONFIG"], logger=logger)
+        else:
+            self._data_src = {}
+            logger.warn(f"{name} config does not have a 'DB_CONFIG' element; defaulting to game_sources={self._data_src}", logging.WARN)
+        if "OGD_CORE_PATH" in all_elements.keys():
+            self._ogd_core = ServerConfigSchema._parseOGDPath(path=all_elements["OGD_CORE_PATH"], logger=logger)
+        else:
+            self._ogd_core = Path("./") / "opengamedata"
+            logger.warn(f"{name} config does not have a 'OGD_CORE_PATH' element; defaulting to ogd_core_path={self._ogd_core}", logging.WARN)
+        if "GOOGLE_CLIENT_ID" in all_elements.keys():
+            self._google_client_id = ServerConfigSchema._parseGoogleID(google_id=all_elements["GOOGLE_CLIENT_ID"], logger=logger)
+        else:
+            self._google_client_id = "UNKNOWN ID"
+            logger.warn(f"{name} config does not have a 'GOOGLE_CLIENT_ID' element; defaulting to google_client_id={self._google_client_id}", logging.WARN)
+        if "DEBUG_LEVEL" in all_elements.keys():
+            self._dbg_level = ServerConfigSchema._parseDebugLevel(all_elements["DEBUG_LEVEL"], logger=logger)
+        else:
+            self._dbg_level = logging.INFO
+            logger.warn(f"{name} config does not have a 'DEBUG_LEVEL' element; defaulting to dbg_level={self._dbg_level}", logging.WARN)
+        if "VER" in all_elements.keys():
+            self._version = ServerConfigSchema._parseVersion(all_elements["VER"], logger=logger)
+        else:
+            self._version = -1
+            logger.warn(f"{name} config does not have a 'VER' element; defaulting to version={self._version}", logging.WARN)
+
+        _used = {"DB_CONFIG", "OGD_CORE_PATH", "GOOGLE_CLIENT_ID", "DEBUG_LEVEL", "VER"}
+        _leftovers = { key : val for key,val in all_elements.items() if key not in _used }
+        super().__init__(name=name, other_elements=_leftovers)
+
+    @property
+    def StateDatabases(self) -> Dict[str, MySQLSchema]:
+        return self._state_dbs
+
+    @property
+    def OGDCore(self) -> Path:
+        return self._ogd_core
+
+    @property
+    def GoogleClientID(self) -> str:
+        return self._google_client_id
+
+    @property
+    def DebugLevel(self) -> int:
+        return self._dbg_level
+
+    @property
+    def Version(self) -> int:
+        return self._version
+
+    @property
+    def AsMarkdown(self) -> str:
+        ret_val : str
+
+        ret_val = f"{self.Name}"
+        return ret_val
+
+    @staticmethod
+    def _parseDataSources(sources, logger:logging.Logger) -> Dict[str, MySQLSchema]:
+        ret_val : Dict[str, MySQLSchema]
+        if isinstance(sources, dict):
+            ret_val = {}
+            for key,val in sources.items():
+                ret_val[key] = MySQLSchema(name=key, all_elements=val)
+        else:
+            ret_val = {}
+            logger.warn(f"Config data sources was unexpected type {type(sources)}, defaulting to empty dict: {ret_val}.", logging.WARN)
+        return ret_val
+
+    @staticmethod
+    def _parseOGDPath(path, logger:logging.Logger) -> Path:
+        ret_val : Path
+        if isinstance(path, str):
+            ret_val = Path(path)
+        else:
+            ret_val = Path("./") / "opengamedata"
+            logger.warn(f"Data Source DB type was unexpected type {type(path)}, defaulting to path={ret_val}.", logging.WARN)
+        return ret_val
+
+    @staticmethod
+    def _parseGoogleID(google_id, logger:logging.Logger) -> str:
+        ret_val : str
+        if isinstance(google_id, str):
+            ret_val = google_id
+        else:
+            ret_val = str(google_id)
+            logger.warn(f"Google Client ID type was unexpected type {type(google_id)}, defaulting to google_client_id=str({ret_val}).", logging.WARN)
+        return ret_val
+
+    @staticmethod
+    def _parseDebugLevel(level, logger:logging.Logger) -> int:
+        ret_val : int
+        if isinstance(level, str):
+            match level.upper():
+                case "ERROR":
+                    ret_val = logging.ERROR
+                case "WARNING" | "WARN":
+                    ret_val = logging.WARN
+                case "INFO":
+                    ret_val = logging.INFO
+                case "DEBUG":
+                    ret_val = logging.DEBUG
+                case _:
+                    ret_val = logging.INFO
+                    logger.warn(f"Config debug level had unexpected value {level}, defaulting to logging.INFO.", logging.WARN)
+        else:
+            ret_val = logging.INFO
+            logger.warn(f"Config debug level was unexpected type {type(level)}, defaulting to logging.INFO.", logging.WARN)
+        return ret_val
+
+    @staticmethod
+    def _parseVersion(version, logger:logging.Logger) -> int:
+        ret_val : int
+        if isinstance(version, int):
+            ret_val = version
+        elif isinstance(version, str):
+            ret_val = int(version)
+        else:
+            ret_val = int(str(version))
+            logger.warn(f"Config version was unexpected type {type(version)}, defaulting to int(str(version))={ret_val}.", logging.WARN)
+        return ret_val

opengamedata_api_utils-1.0.0/src/ogd/apis/utils/APIResponse.py

@@ -0,0 +1,164 @@
+"""
+APIResponse
+
+Contains class for representing a response from an OGD API,
+as well as utility enums used by the APIResponse class.
+"""
+
+# import standard libraries
+import json
+from enum import IntEnum
+from typing import Any, Dict
+
+# import 3rd-party libraries
+
+# import OGD libraries
+import ogd.core.requests.RequestResult as RequestResult
+
+# Import local files
+
+class RESTType(IntEnum):
+    """Simple enumerated type to track type of a REST request.
+    """
+    GET = 1
+    POST = 2
+    PUT = 3
+
+    def __str__(self):
+        """Stringify function for RESTTypes.
+
+        :return: Simple string version of the name of a RESTType
+        :rtype: _type_
+        """
+        match self.value:
+            case RESTType.GET:
+                return "GET"
+            case RESTType.POST:
+                return "POST"
+            case RESTType.PUT:
+                return "PUT"
+            case _:
+                return "INVALID REST TYPE"
+
+class ResponseStatus(IntEnum):
+    """Simple enumerated type to track the status of an API request result.
+    """
+    NONE = 1
+    SUCCESS = 200
+    ERR_REQ = 400
+    ERR_SRV = 500
+
+    def __str__(self):
+        """Stringify function for ResponseStatus objects.
+
+        :return: Simple string version of the name of a ResponseStatus
+        :rtype: _type_
+        """
+        match self.value:
+            case ResponseStatus.NONE:
+                return "NONE"
+            case ResponseStatus.SUCCESS:
+                return "SUCCESS"
+            case ResponseStatus.ERR_SRV:
+                return "SERVER ERROR"
+            case ResponseStatus.ERR_REQ:
+                return "REQUEST ERROR"
+            case _:
+                return "INVALID STATUS TYPE"
+
+class APIResponse:
+    def __init__(self, req_type:RESTType, val:Any, msg:str, status:ResponseStatus):
+        self._type   : RESTType       = req_type
+        self._val    : Dict[str, Any] = val
+        self._msg    : str            = msg
+        self._status : ResponseStatus   = status
+
+    def __str__(self):
+        return f"{self.Type.name} request: {self.Status}\n{self.Message}\nValues: {self.Value}"
+
+    @staticmethod
+    def Default(req_type:RESTType):
+        return APIResponse(
+            req_type=req_type,
+            val=None,
+            msg="",
+            status=ResponseStatus.NONE
+        )
+
+    @staticmethod
+    def FromRequestResult(result:RequestResult.RequestResult, req_type:RESTType):
+        _status : ResponseStatus
+        if result.Status == RequestResult.ResultStatus.SUCCESS:
+            _status = ResponseStatus.SUCCESS 
+        elif result.Status == RequestResult.ResultStatus.FAILURE:
+            _status = ResponseStatus.ERR_REQ
+        else:
+            _status = ResponseStatus.ERR_SRV
+        ret_val = APIResponse(req_type=req_type, val=None, msg=result.Message, status=_status)
+        return ret_val
+
+    @property
+    def Type(self) -> RESTType:
+        """Property for the type of REST request
+
+        :return: A RESTType representing the type of REST request
+        :rtype: _type_
+        """
+        return self._type
+
+    @property
+    def Value(self) -> Dict[str, Any]:
+        """Property for the value of the request result.
+
+        :return: Some value, of any type, returned from the request.
+        :rtype: Any
+        """
+        return self._val
+    @Value.setter
+    def Value(self, new_val:Dict[str, Any]):
+        self._val = new_val
+
+
+    @property
+    def Message(self) -> str:
+        """Property for the message associated with a request result.
+
+        :return: A string message giving details on the result of the request.
+        :rtype: str
+        """
+        return self._msg
+
+    @property
+    def Status(self) -> ResponseStatus:
+        """Property for the status of the request.
+
+        :return: A ResponseStatus indicating whether request is/was successful, incomplete, failed, etc.
+        :rtype: ResponseStatus
+        """
+        return self._status
+
+    @property
+    def AsDict(self):
+        return {
+            "type"   : str(self._type),
+            "val"    : json.dumps(self._val),
+            "msg"    : self._msg,
+            "status" : str(self._status)
+        }
+
+    @property
+    def AsJSON(self):
+        return json.dumps(self.AsDict)
+
+    def RequestErrored(self, msg:str):
+        self._status = ResponseStatus.ERR_REQ
+        self._msg = f"ERROR: {msg}"
+
+    def ServerErrored(self, msg:str):
+        self._status = ResponseStatus.ERR_SRV
+        self._msg = f"SERVER ERROR: {msg}"
+
+    def RequestSucceeded(self, msg:str, val:Any):
+        self._status = ResponseStatus.SUCCESS
+        self._msg = f"SUCCESS: {msg}"
+        self._val = val

opengamedata_api_utils-1.0.0/src/ogd/apis/utils/APIUtils.py

@@ -0,0 +1,92 @@
+"""
+APIUtils
+
+Contains general utility functions for common  tasks when setting up our flask/flask-restful API functions.
+In particular, has functions to assist in parsing certain kinds of data, and for generating OGD-core objects.
+"""
+
+# import standard libraries
+import json
+import os
+from typing import Any, List, Optional
+
+# import 3rd-party libraries
+from flask import current_app
+
+# import OGD libraries
+from ogd.core.interfaces.DataInterface import DataInterface
+from ogd.core.interfaces.MySQLInterface import MySQLInterface
+from ogd.core.interfaces.BigQueryInterface import BigQueryInterface
+from ogd.core.schemas.configs.ConfigSchema import ConfigSchema
+from ogd.core.schemas.configs.GameSourceSchema import GameSourceSchema
+
+# import local files
+
+def parse_list(list_str:str) -> Optional[List[Any]]:
+    """Simple utility to parse a string containing a bracketed list into a Python list.
+    Returns None if the list was empty
+
+    :param list_str: _description_
+    :type list_str: str
+    :return: A list parsed from the input string, or None if the string list was invalid or empty.
+    :rtype: Union[List[Any], None]
+    """
+    ret_val : Optional[List[Any]] = None
+    try:
+        ret_val = json.loads(list_str)
+    except json.decoder.JSONDecodeError as e:
+        current_app.logger.warn(f"Could not parse '{list_str}' as a list, format was not valid!\nGot Error {e}")
+    else:
+        if ret_val is not None and len(ret_val) == 0:
+            # If we had empty list, just treat as null.
+            ret_val = None
+    return ret_val
+
+def gen_interface(game_id, core_config:ConfigSchema) -> Optional[DataInterface]:
+    """Utility to set up an Interface object for use by the API, given a game_id.
+
+    :param game_id: _description_
+    :type game_id: _type_
+    :return: _description_
+    :rtype: _type_
+    """
+    ret_val = None
+    
+    _game_source : GameSourceSchema = core_config.GameSourceMap.get(game_id, GameSourceSchema.EmptySchema())
+
+    if _game_source.Source is not None:
+        # set up interface and request
+        if _game_source.Source.Type.upper() == "MYSQL":
+            ret_val = MySQLInterface(game_id, config=_game_source, fail_fast=False)
+            current_app.logger.info(f"Using MySQLInterface for {game_id}")
+        elif _game_source.Source.Type.upper() == "BIGQUERY":
+            current_app.logger.info(f"Generating BigQueryInterface for {game_id}, from directory {os.getcwd()}...")
+            ret_val = BigQueryInterface(game_id=game_id, config=_game_source, fail_fast=False)
+            current_app.logger.info("Done")
+        else:
+            ret_val = MySQLInterface(game_id, config=_game_source, fail_fast=False)
+            current_app.logger.warning(f"Could not find a valid interface for {game_id}, defaulting to MySQL!")
+    return ret_val
+
+# def gen_coding_interface(game_id) -> Optional[CodingInterface]:
+#     """Utility to set up an Interface object for use by the API, given a game_id.
+
+#     :param game_id: _description_
+#     :type game_id: _type_
+#     :return: _description_
+#     :rtype: _type_
+#     """
+#     ret_val = None
+
+#     _core_config = ConfigSchema(name="Core Config", all_elements=core_settings)
+#     _game_source : GameSourceSchema = _core_config.GameSourceMap.get(game_id, GameSourceSchema.EmptySchema())
+
+#     if _game_source.Source is not None:
+#         # set up interface and request
+#         if _game_source.Source.Type == "BigQuery":
+#             ret_val = BigQueryCodingInterface(game_id=game_id, config=_core_config)
+#             current_app.logger.info(f"Using BigQueryCodingInterface for {game_id}")
+#         else:
+#             ret_val = BigQueryCodingInterface(game_id=game_id, config=_core_config)
+#             current_app.logger.warning(f"Could not find a valid interface for {game_id}, defaulting to BigQuery!")
+#     return ret_val

opengamedata_api_utils-1.0.0/src/ogd/apis/utils/HelloAPI.py

@@ -0,0 +1,73 @@
+"""
+HelloAPI
+
+Contains the HelloAPI class, which we register to all API apps as a way to test that the app is active.
+"""
+
+# import libraries
+
+# import 3rd-party libraries
+from flask import Flask
+from flask_restful import Resource, Api
+
+# import OGD libraries
+from ogd.apis.utils.APIResponse import APIResponse, RESTType, ResponseStatus
+
+# import locals
+
+class HelloAPI:
+    @staticmethod
+    def register(app:Flask):
+        api = Api(app)
+        api.add_resource(HelloAPI.Hello, '/hello')
+        api.add_resource(HelloAPI.ParamHello, '/p_hello/<name>')
+
+    class Hello(Resource):
+        def get(self):
+            ret_val = APIResponse(
+                req_type = RESTType.GET,
+                val      = None,
+                msg      = "Hello! You GETted successfully!",
+                status   = ResponseStatus.SUCCESS)
+            return ret_val.AsDict
+
+        def post(self):
+            ret_val = APIResponse(
+                req_type = RESTType.POST,
+                val      = None,
+                msg      = "Hello! You POSTed successfully!",
+                status   = ResponseStatus.SUCCESS)
+            return ret_val.AsDict
+
+        def put(self):
+            ret_val = APIResponse(
+                req_type = RESTType.PUT,
+                val      = None,
+                msg      = "Hello! You PUTted successfully!",
+                status   = ResponseStatus.SUCCESS)
+            return ret_val.AsDict
+
+    class ParamHello(Resource):
+        def get(self, name):
+            ret_val = APIResponse(
+                req_type = RESTType.GET,
+                val      = None,
+                msg      = f"Hello {name}! You GETted successfully!",
+                status   = ResponseStatus.SUCCESS)
+            return ret_val.AsDict
+
+        def post(self, name):
+            ret_val = APIResponse(
+                req_type = RESTType.POST,
+                val      = None,
+                msg      = f"Hello {name}! You POSTed successfully!",
+                status   = ResponseStatus.SUCCESS)
+            return ret_val.AsDict
+
+        def put(self, name):
+            ret_val = APIResponse(
+                req_type = RESTType.PUT,
+                val      = None,
+                msg      = f"Hello {name}! You PUTted successfully!",
+                status   = ResponseStatus.SUCCESS)
+            return ret_val.AsDict

opengamedata_api_utils-1.0.0/src/opengamedata_api_utils.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: opengamedata-api-utils
+Version: 1.0.0
+Summary: Package of utilities for server-side scripts in OpenGameData.
+Author: Ryan Wilkinson, Glenn Palmer, Daus Husaini
+Author-email: Luke Swanson <superscription58@gmail.com>
+Project-URL: Homepage, https://github.com/opengamedata/opengamedata-api-utils
+Project-URL: Bug Tracker, https://github.com/opengamedata/opengamedata-api-utils/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# opengamedata-server
+
+Repository for server-side scripts in opengamedata. In particular, this is where we have code for the OGD APIs.
+
+## Getting Started
+
+### Hello World of Flask
+
+Steps to run:
+1. Check out latest `opengamedata-server`.
+2. Run `pip install -r requirements.txt` to ensure you've got flask.
+3. Run `flask run`.
+4. Open localhost:5000 or localhost:5000/hello to see some really basic text output from the Flask server.
+
+If Flask doesn't run, it's possible you'd need to first export FLASK_APP as an environment variable, set to "wsgi" (so in Bash, export FLASK_APP=wsgi).
+However, the script is named wsgi.py specifically because Flask is supposed to auto-detect it. So if this issue ever did come up, please ping Luke so he can look into it.
+
+## APIs
+
+Below is a listing of the current API calls available, in function format to indicate what the request parameters.
+For each API, there is also an api path, with path parameters in angle bracket (<, >) format.
+Lastly, at this point in time, the `<server_path>` is `https://fieldday-web.wcer.wisc.edu/opengamedata.wsgi`
+
+### Classroom API
+
+### Dashboard API
+
+### Hello API
+
+#### Verify the API is alive
+
+`<server_path>/hello`  
+`GET()`
+
+- returns no value, and a success message  
+
+`POST()`
+
+- returns no value, and a success message
+
+`PUT()`
+
+- returns no value, and a success message
+
+
+### Player API
+
+### Generate and save players
+
+`<server_path>/player`  
+`GET()`
+
+- returns an unused, randomized player name, or a null value and error message  
+
+`PUT(str player_id, str name = None)`
+
+- Returns no value, and either a success or error message  
+---

opengamedata_api_utils-1.0.0/src/opengamedata_api_utils.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/ogd/apis/__init__.py
+src/ogd/apis/schemas/ServerConfigSchema.py
+src/ogd/apis/schemas/__init__.py
+src/ogd/apis/utils/APIResponse.py
+src/ogd/apis/utils/APIUtils.py
+src/ogd/apis/utils/HelloAPI.py
+src/ogd/apis/utils/__init__.py
+src/opengamedata_api_utils.egg-info/PKG-INFO
+src/opengamedata_api_utils.egg-info/SOURCES.txt
+src/opengamedata_api_utils.egg-info/dependency_links.txt
+src/opengamedata_api_utils.egg-info/top_level.txt

opengamedata_api_utils-1.0.0/src/opengamedata_api_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opengamedata_api_utils-1.0.0/src/opengamedata_api_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+ogd