| check_game_roles_duplicates |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/utilities.py code served (permissive licence) · get_code("5a1f9577a7a8d923") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
ARGS = {
"id_role_mapping": {
"player_1": ["role_a"],
"player_2": ["role_b", "role_c"],
"player_3": ["role_d", "role_e", "role_f"],
"player_4": ["role_g"]
}
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| create_static_features |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/features.py code served (permissive licence) · get_code("7b1232890f213204") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import pandas as pd
# Create a small stand-in DataFrame with moments
# The function expects events_df to have a 'moments' column
# Each moment is a flattened array of shape (n_pl * 4 + 2 + 2,) for a single moment
# or a list/array of such moments
def create_sample_moments(n_pl):
"""Create sample moments for testing"""
# Each moment has:
# - n_pl * 4 values for player positions (n_pl players * 2 coordinates)
# - 2 values for ball position
# - 2 values for hoop position (but these are computed, not in input)
# Total input: n_pl * 4 + 2
moment_size = n_pl * 4 + 2
# Create 3 sample moments
moments_list = [
np.random.randn(moment_size).astype(np.float32),
np.random.randn(moment_size).astype(np.float32),
np.random.randn(moment_size).astype(np.float32),
]
return moments_list
# Create events_df with n_pl=5 (basketball)
n_pl_val = 5
events_data = {
'moments': [
create_sample_moments(n_pl_val),
create_sample_moments(n_pl_val),
]
}
events_df = pd.DataFrame(events_data)
ARGS = {
'events_df': events_df,
'n_pl': n_pl_val,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| flatten_moments |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/features.py code served (permissive licence) · get_code("5614066a824dbc29") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import pandas as pd
# Create a minimal events_df with the structure expected by flatten_moments
# The function expects:
# - A 'moments' column containing lists of moments
# - Each moment is a tuple/list where:
# - moment[0] is a numeric value (game_clock or similar)
# - moment[2] is a numeric value
# - moment[3] is a numeric value
# - moment[5] is a numpy array with shape (11, 5) representing 10 players + 1 ball
# - rows 1:6 are team 1 players (5 players)
# - rows 6:11 are team 2 players (5 players)
# - rows 0 is the ball
# - columns are [team_id, player_id, x, y, z] where x, y are in feet
def create_moment(game_clock, val2, val3, team1_id=1, team2_id=2):
"""Create a valid moment structure"""
# Create the player/ball array: 11 rows x 5 columns
m = np.zeros((11, 5))
# Ball (row 0): [team_id, player_id, x, y, z]
m[0] = np.array([0, -1, 47.0, 25.0, 0.0])
# Team 1 players (rows 1-5)
for i in range(1, 6):
m[i] = np.array([team1_id, i, 20.0 + i, 10.0 + i, 0.0])
# Team 2 players (rows 6-11)
for i in range(6, 11):
m[i] = np.array([team2_id, i, 60.0 + i, 30.0 + i, 0.0])
# moment is [game_clock, ?, val2, val3, ?, moments_array]
moment = [game_clock, None, val2, val3, None, m]
return moment
# Create sample data
moments_list_1 = [
create_moment(600.0, 100.0, 200.0, team1_id=1, team2_id=2),
create_moment(599.5, 101.0, 201.0, team1_id=1, team2_id=2),
]
moments_list_2 = [
create_moment(598.0, 102.0, 202.0, team1_id=1, team2_id=2),
create_moment(597.5, 103.0, 203.0, team1_id=1, team2_id=2),
]
events_df = pd.DataFrame({
'moments': [moments_list_1, moments_list_2]
})
ARGS = {
'events_df': events_df,
'normalize': True,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_params_str |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/vrnn/models/utils.py code served (permissive licence) · get_code("a2044933b17736c4") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
def get_params_str(model_args, params):
ret = ''
for arg in model_args:
ret += ' {} {} |'.format(arg, params[arg])
return ret[1:-2]
model_args = ['learning_rate', 'batch_size', 'hidden_dim']
params = {
'learning_rate': 0.001,
'batch_size': 32,
'hidden_dim': 64
}
ARGS = {
'model_args': model_args,
'params': params
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_sequences |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/sequencing.py code served (permissive licence) · get_code("355994bf463714bb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a minimal single_game structure
# Based on the code, it accesses indices up to around 551 for basketball
# We need shape[1] to be at least 552 for n_pl=5 case
single_game = [np.random.randn(10, 600)] # 10 timesteps, 600 features
# policy is iterated over, appears to be a list/array of indices
policy = [0, 1]
# sequence_length: used for creating sequences
sequence_length = 5
# overlap: used for sequence generation
overlap = 2
# n_pl: number of players (5 for basketball, 11 for soccer)
n_pl = 5
# k_nearest: number of nearest players
k_nearest = 3
# n_feat: number of features per nearest player
n_feat = 4
# velocity: flag for velocity (0, 1, or 2)
velocity = 1
# in_sma: boolean flag
in_sma = False
ARGS = {
'single_game': single_game,
'policy': policy,
'sequence_length': sequence_length,
'overlap': overlap,
'n_pl': n_pl,
'k_nearest': k_nearest,
'n_feat': n_feat,
'velocity': velocity,
'in_sma': in_sma
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| id_player |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/utilities.py code served (permissive licence) · get_code("df8527ed08f0823e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import pandas as pd
# Create a small dataframe with the structure expected by id_player
# The function expects each row to have 'home' and 'visitor' columns
# containing dicts with 'players' lists
home_team_1 = {
'players': [
{'playerid': 1, 'firstname': 'John', 'lastname': 'Doe'},
{'playerid': 2, 'firstname': 'Jane', 'lastname': 'Smith'},
]
}
away_team_1 = {
'players': [
{'playerid': 3, 'firstname': 'Bob', 'lastname': 'Johnson'},
{'playerid': 4, 'firstname': 'Alice', 'lastname': 'Williams'},
]
}
home_team_2 = {
'players': [
{'playerid': 1, 'firstname': 'John', 'lastname': 'Doe'},
{'playerid': 5, 'firstname': 'Charlie', 'lastname': 'Brown'},
]
}
away_team_2 = {
'players': [
{'playerid': 3, 'firstname': 'Bob', 'lastname': 'Johnson'},
{'playerid': 6, 'firstname': 'Diana', 'lastname': 'Miller'},
]
}
event_df = pd.DataFrame({
'home': [home_team_1, home_team_2],
'visitor': [away_team_1, away_team_2]
})
ARGS = {
'event_df': event_df
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| id_position |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/utilities.py code served (permissive licence) · get_code("eb7beff2f5f867dc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import pandas as pd
import numpy as np
# Create a minimal DataFrame with the structure expected by id_position
# The function expects event_df to have rows where each row contains 'home' and 'visitor' data
# Each of those contains a 'players' list with dicts having 'playerid' and 'position' keys
event_data = []
# First event with home and away players
event_1 = {
'home': {
'players': [
{'playerid': 1, 'position': 'goalkeeper'},
{'playerid': 2, 'position': 'defender'},
{'playerid': 3, 'position': 'midfielder'},
]
},
'visitor': {
'players': [
{'playerid': 10, 'position': 'goalkeeper'},
{'playerid': 11, 'position': 'defender'},
{'playerid': 12, 'position': 'forward'},
]
}
}
# Second event with some overlapping and some new players
event_2 = {
'home': {
'players': [
{'playerid': 1, 'position': 'goalkeeper'},
{'playerid': 2, 'position': 'defender'},
{'playerid': 4, 'position': 'forward'},
]
},
'visitor': {
'players': [
{'playerid': 10, 'position': 'goalkeeper'},
{'playerid': 11, 'position': 'defender'},
{'playerid': 13, 'position': 'midfielder'},
]
}
}
event_data.append(event_1)
event_data.append(event_2)
event_df = pd.DataFrame({
'home': [event_data[0]['home'], event_data[1]['home']],
'visitor': [event_data[0]['visitor'], event_data[1]['visitor']]
})
ARGS = {
'event_df': event_df
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| num_trainable_params |
Ran ran, honoured the contract we drafted |
keisuke198619/PO-MC-DHVRNN/vrnn/models/utils.py pointer only (licence: MIT); the stored copy get_code serves, from felixykliu/NAOMI, is pointer only (licence: NONE) · get_code("dcc2aedb4ca9a4e8") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from felixykliu/NAOMI, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| parse_model_params |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/vrnn/models/utils.py code served (permissive licence) · get_code("1b07b23dc05534d2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import argparse
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a minimal argument parser
parser = argparse.ArgumentParser()
# Define model arguments - these will be added as command-line arguments
model_args = ['hidden_size', 'num_layers', 'dropout']
# Create a params dict to be updated
params = {
'learning_rate': 0.001,
'batch_size': 32
}
# Simulate command-line arguments by setting sys.argv
import sys
sys.argv = ['script.py', '--hidden_size', '128', '--num_layers', '3', '--dropout', '1']
ARGS = {
'model_args': model_args,
'params': params,
'parser': parser
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| remove_non_eleven |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/preprocessing.py code served (permissive licence) · get_code("6c4fda6e44757193") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import pandas as pd
import numpy as np
# Construct a minimal events_df with the required structure
# The function expects a DataFrame with 'moments' column and home/visitor info
# Create sample moments data
# For n_pl=5 case: moments[i][5] should contain player data (11 elements when valid)
# For n_pl=10 case: moments[i][0] should contain player data (46 elements when valid)
def create_sample_moments(n_moments, n_pl, valid=True):
"""Create sample moments with the correct structure."""
moments = []
for i in range(n_moments):
if n_pl == 5:
# Structure: [time, quarter, ..., players_list, ...]
# moments[i][5] should be the players list
if valid:
players = [{'x': j, 'y': j+1} for j in range(11)]
else:
players = [{'x': j, 'y': j+1} for j in range(5)] # Invalid: fewer than 11
moment = [0, 1, 2, 3, 4, players]
else:
# For n_pl=10: moments[i][0] should be the players list
if valid:
players = [{'x': j, 'y': j+1} for j in range(46)]
else:
players = [{'x': j, 'y': j+1} for j in range(20)] # Invalid: fewer than 46
moment = [players]
moments.append(moment)
return moments
# Create events dataframe with valid and invalid moments
valid_moments = create_sample_moments(12, n_pl=5, valid=True)
invalid_moments = create_sample_moments(2, n_pl=5, valid=False)
mixed_moments = valid_moments[:5] + invalid_moments + valid_moments[5:]
events_df = pd.DataFrame({
'moments': [mixed_moments, valid_moments],
'home': [
{'teamid': 'home_team_1'},
{'teamid': 'home_team_2'}
],
'visitor': [
{'teamid': 'away_team_1'},
{'teamid': 'away_team_2'}
]
})
ARGS = {
'events_df': events_df,
'event_length_th': 3,
'n_pl': 5,
'verbose': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| remove_outlier |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/preprocessing.py code served (permissive licence) · get_code("fbdba52436f13206") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import pandas as pd
# Create sample data for the function
np.random.seed(0)
# Create a DataFrame with 'moments' column
# Each moment is an array with shape (num_frames, 528)
# Indices 506:526 are player velocities (10 players * 2 coords = 20 values)
# Indices 526:528 are ball velocities (2 coords)
n_players = 10
n_frames = 5
# Create moments array with shape (n_frames, 528)
# First 506 columns are dummy data
# Columns 506:526 are player velocities (10 players)
# Columns 526:528 are ball velocities
moments_1 = np.random.randn(n_frames, 528) * 0.1
# Set velocities to valid range (below thresholds: ball < 20, players < 13)
moments_1[:, 506:526] = np.random.randn(n_frames, 20) * 5 # player velocities < 13
moments_1[:, 526:528] = np.random.randn(n_frames, 2) * 8 # ball velocities < 20
moments_2 = np.random.randn(n_frames, 528) * 0.1
moments_2[:, 506:526] = np.random.randn(n_frames, 20) * 5
moments_2[:, 526:528] = np.random.randn(n_frames, 2) * 8
# Create DataFrame with moments column
events_df = pd.DataFrame({
'moments': [moments_1, moments_2],
'other_col': [1, 2]
})
ARGS = {
'events_df': events_df,
'n_pl': n_players,
'verbose': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| subsample_sequence |
Ran ran on a synthesized input |
keisuke198619/PO-MC-DHVRNN/sequencing.py code served (permissive licence) · get_code("621c945f84c310f5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from scipy import signal
# Create sample event sequences
# The function expects a list of arrays (events), where each array has shape (n_moments, n_features)
events = [
np.random.randn(10, 4), # First sequence: 10 time steps, 4 features
np.random.randn(12, 4), # Second sequence: 12 time steps, 4 features
]
# Define arguments
ARGS = {
"events": events,
"subsample_factor": 2,
"random_sample": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list — a list output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| filters |
Not yet run unverified (harvested, no recorded run) |
keisuke198619/PO-MC-DHVRNN/preprocessing.py code served (permissive licence) · get_code("3387d8452713966d") How it ran |
| flatten_moments_soccer |
Not yet run unverified (harvested, no recorded run) |
keisuke198619/PO-MC-DHVRNN/features.py code served (permissive licence) · get_code("cd67ed55902cba6d") How it ran |