first draft of loading script

nba_tracking_data_15_16.py

@@ -12,92 +12,123 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # TODO: Address all TODOs and remove all explanatory comments
-"""TODO: Add a description here."""
+"""This is tracking data of the 2015-2016 NBA season"""
 
 
 import csv
 import json
 import os
+import py7zr
 
 import datasets
+import requests
 
 
-# TODO: Add BibTeX citation
-# Find for instance the citation on arxiv or on the dataset repo/website
 _CITATION = """\
-@InProceedings{huggingface:dataset,
-title = {A great new dataset},
-author={huggingface, Inc.
-},
-year={2020}
-}
+@misc{Linou2016,
+title = {NBA-Player-Movements},
+author={Kostya Linou},
+publisher={SportVU},
+year={2016}
 """
 
-# TODO: Add description of the dataset here
-# You can copy an official description
+
 _DESCRIPTION = """\
-This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
+This dataset is designed to give further easy access to tracking data.
+By merging all .7z files into one large .json file, access is easier to retrieve all information at once.
 """
 
-# TODO: Add a link to an official homepage for the dataset here
-_HOMEPAGE = ""
-
-# TODO: Add the licence for the dataset here if you can find it
-_LICENSE = ""
-
-# TODO: Add link to the official dataset URLs here
-# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
-# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
-_URLS = {
-    "first_domain": "https://huggingface.co/great-new-dataset-first_domain.zip",
-    "second_domain": "https://huggingface.co/great-new-dataset-second_domain.zip",
-}
-
-
-# TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
-class NewDataset(datasets.GeneratorBasedBuilder):
-    """TODO: Short description of my dataset."""
-
-    VERSION = datasets.Version("1.1.0")
+_HOMEPAGE = "https://github.com/linouk23/NBA-Player-Movements/tree/master/"
 
-    # This is an example of a dataset with multiple configurations.
-    # If you don't want/need to define several sub-sets in your dataset,
-    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+res = requests.get(_HOMEPAGE)
 
-    # If you need to make complex sub-parts in the datasets with configurable options
-    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
-    # BUILDER_CONFIG_CLASS = MyBuilderConfig
+items = res.json()['payload']['tree']['items']
 
-    # You will be able to load one or the other configurations in the following list with
-    # data = datasets.load_dataset('my_dataset', 'first_domain')
-    # data = datasets.load_dataset('my_dataset', 'second_domain')
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="first_domain", version=VERSION, description="This part of my dataset covers a first domain"),
-        datasets.BuilderConfig(name="second_domain", version=VERSION, description="This part of my dataset covers a second domain"),
-    ]
+_URL = "https://github.com/linouk23/NBA-Player-Movements/raw/master/data/2016.NBA.Raw.SportVU.Game.Logs"
+_URLS = {}
+for game in items:
+  name = game['name'][:-3]
+  _URLS[name] = _URL + "/" + name + ".7z"
 
-    DEFAULT_CONFIG_NAME = "first_domain"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+class NbaTracking(datasets.GeneratorBasedBuilder):
+    """Tracking data for all games of 2015-2016 season in forms of coordinates for players and ball at each moment."""
 
     def _info(self):
-        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
-        if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
-            features = datasets.Features(
-                {
-                    "sentence": datasets.Value("string"),
-                    "option1": datasets.Value("string"),
-                    "answer": datasets.Value("string")
-                    # These are the features of your dataset like images, labels ...
-                }
-            )
-        else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
-            features = datasets.Features(
-                {
-                    "sentence": datasets.Value("string"),
-                    "option2": datasets.Value("string"),
-                    "second_domain_answer": datasets.Value("string")
-                    # These are the features of your dataset like images, labels ...
-                }
-            )
+        features = datasets.Features(
+            {    
+                "gameid": datasets.Value("string"),
+                "gamedate": datasets.Value("string"),
+                # question: how to indicate list of dictionaries?
+                "events": datasets.Sequence(
+                    {
+                         "eventid": datasets.Value("string"),
+                        # "visitor": {
+                        #     "name": datasets.Value("string"),
+                        #     "teamid": datasets.Value("int64"),
+                        #     "abbreviation": datasets.Value("string"),
+                        #     "players": datasets.Sequence({
+                        #         "lastname": datasets.Value("string"),
+                        #         "firstname": datasets.Value("string"),
+                        #         "playerid": datasets.Value("int64"),
+                        #         "jersey": datasets.Value("string"),
+                        #         "position": datasets.Value("string")
+                        #     })
+                        # },
+                        # "home": {
+                        #     "name": datasets.Value("string"),
+                        #     "teamid": datasets.Value("int64"),
+                        #     "abbreviation": datasets.Value("string"),
+                        #     "players": datasets.Sequence({
+                        #         "lastname": datasets.Value("string"),
+                        #         "firstname": datasets.Value("string"),
+                        #         "playerid": datasets.Value("int64"),
+                        #         "jersey": datasets.Value("string"),
+                        #         "position": datasets.Value("string")
+                        #     })
+                        # },
+                        "moments": datasets.Sequence(
+                            # question, how to indicate lists of lists of different types
+                            {
+                                "quarter": datasets.Value("int64"),
+                                "game_clock": datasets.Value("float32"),
+                                "shot_clock": datasets.Value("float32"),
+                                "ball_coordinates": datasets.Sequence(
+                                    datasets.Value("float32"),
+                                    datasets.Value("float32"),
+                                    datasets.Value("float32")
+                                ),
+                                "player_coordinates": datsets.Sequence(
+                                    {
+                                        "teamid": datasets.Value("int64"),
+                                        "playerid": datasets.Value("int64"),
+                                        "x": datasets.Value("float32"),
+                                        "y": datasets.Value("float32"),
+                                        "z": datasets.Value("float32")
+                                    }
+                                )
+                            }
+                            # datasets.Sequence(
+                            #     datasets.Value("int64"),
+                            #     datasets.Value("float32"),
+                            #     datasets.Value("float32"),
+                            #     datasets.Value("float32"),
+                            #     datasets.Value("null"),
+                            #     datasets.Sequence(
+                            #         datasets.Sequence(
+                            #             datasets.Value("int64"),
+                            #             datasets.Value("int64"),
+                            #             datasets.Value("float32"),
+                            #             datasets.Value("float32"),
+                            #             datasets.Value("float32")
+                            #         )
+                            #     )
+                            # )
+                        )
+                    }
+                )
+            }
+        )
+        
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
@@ -108,65 +139,82 @@ class NewDataset(datasets.GeneratorBasedBuilder):
             # supervised_keys=("sentence", "label"),
             # Homepage of the dataset for documentation
             homepage=_HOMEPAGE,
-            # License for the dataset if available
-            license=_LICENSE,
             # Citation for the dataset
             citation=_CITATION,
         )
 
     def _split_generators(self, dl_manager):
         # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
-        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
-
+        
         # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
         # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
         # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
         urls = _URLS[self.config.name]
         data_dir = dl_manager.download_and_extract(urls)
+        
+        all_file_paths = {}
+        for key, directory_path in data_dir.items():
+            all_file_paths[key] = os.path.join(directory_path, os.listdir(directory_path))
+            
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": os.path.join(data_dir, "train.jsonl"),
+                    "filepaths": all_file_paths,
                     "split": "train",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": os.path.join(data_dir, "dev.jsonl"),
-                    "split": "dev",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": os.path.join(data_dir, "test.jsonl"),
-                    "split": "test"
-                },
-            ),
+                }
+            )
         ]
 
     # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
     def _generate_examples(self, filepath, split):
         # TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
         # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
-        with open(filepath, encoding="utf-8") as f:
-            for key, row in enumerate(f):
-                data = json.loads(row)
-                if self.config.name == "first_domain":
-                    # Yields examples as (key, example) tuples
-                    yield key, {
-                        "sentence": data["sentence"],
-                        "option1": data["option1"],
-                        "answer": "" if split == "test" else data["answer"],
-                    }
-                else:
-                    yield key, {
-                        "sentence": data["sentence"],
-                        "option2": data["option2"],
-                        "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
-                    }
+        for link in filepath:
+            with open(link, encoding="utf-8") as fp:
+                game_id = json.load(fp)["gameid"]
+                game_date = json.load(fp)["gamedate"] 
+                for event in json.load(fp)["events"]:
+                    event_id = event["eventId"]
+                    for moment in event["moments"]:
+                        for element in moment:
+                            quarter = element[0]
+                            game_clock = element[2]
+                            shot_clock = element[3]
+                            ball_coords = element[5][0][2:]
+                            for position in element[5][1:]:
+                                team_id = position[0]
+                                player_id = position[1]
+                                x = position[2]
+                                y = position[3]
+                                z = position[4]
+                                
+                                yield game_id, {
+                                    "gameid": game_id,
+                                    "gamedate": game_date,
+                                    "events": {
+                                        "eventid": event_id,
+                                        "moments": {
+                                            "quarter": quarter,
+                                            "game_clock": game_clock,
+                                            "shot_clock": shot_clock,
+                                            "ball_coordinates": ball_coords,
+                                            "player_coordinates": {
+                                                "teamid": team_id,
+                                                "playerid": player_id,
+                                                "x": x,
+                                                "y": y,
+                                                "z": z
+                                            }
+                                        }
+                                    }
+                                }
+                                
+                        
+                # for key, row in enumerate(fp):
+                #     data = json.load(row)
+                #     # Yields examples as (key, example) tuples
+                #     yield key, {
+                        
+                #     }