initial commit

athleticotogo/athletico.py

@@ -0,0 +1,111 @@
+import requests
+from requests import RequestException
+import json
+import jinja2
+from pathlib import Path
+
+class Athletico():
+    def fetch_episodes_for_access_code(self, access_code:str) -> dict:
+        '''
+        Given a home access code, fetch exercise information
+        :param access_code: the access code to a home excercise program from Athletico
+        :return: a dict containing the exercise information
+        '''
+        session = requests.Session()
+        home_url = "https://athleticopt.medbridgego.com"
+        fetch_episodes_url = "https://athleticopt.medbridgego.com/api/v4/lite/episodes/"
+
+        session.get(home_url)
+        csrf_token = session.cookies.get('csrf_cookie_name')
+
+        session.post(
+            url="https://athleticopt.medbridgego.com/register_token",
+            data = {
+                "token": access_code,
+                "X-CSRF-Token": csrf_token,
+                "verify_access_code": "Verify+Access+Code"
+            }
+        )
+
+        response = session.get(fetch_episodes_url)
+
+        if response.ok and response.json() and response.json().get('status'):
+            return response.json().get('episodes')
+        else:
+            raise RequestException(f'Request Failed, {response.status_code}: {response.reason}')
+
+    def render(self,  template: str, output: str, context: dict) -> str:
+        '''
+        Renders an HTML page.
+        :param template: Path to jinja template
+        :param output: Destination for .html file
+        :param context: The context to be passed to the render
+        :return: Path to html file
+        '''
+
+        output_filepath = Path(output)
+        template_filepath = Path(output)
+        environment = jinja2.Environment(loader=jinja2.FileSystemLoader())
+        template = environment.get_template(template_filepath)
+        page = template.render(**context)
+
+        output_filepath.mkdir(parents=True, exist_ok=True)
+        with output_filepath.open('w') as f:
+            f.write(page)
+
+        return str(output_filepath)
+
+    def save_episodes(self, episodes: list, destination: str= ".") -> None:
+        '''
+        Outputs episodes to disk in a folder structure
+        :param episodes: List of episode data, matches output of fetch_episodes_for_access_code
+        :param destination: Filepath to save to, defaults to current directory
+        :return: None
+        '''
+
+        destination_filepath = Path(destination)
+        destination_filepath.joinpath()
+        for episode in episodes:
+            episode_id = str(episode['id'])
+            program = episode['program']
+            exercises = []
+            episode_filepath = destination_filepath.joinpath('programs',episode["token"],'episodes')
+            episode_filepath.mkdir(parents=True, exist_ok=True)
+
+            for exercise in program['program_exercises']:
+                exercises.append(exercise)
+                exercise_id = str(exercise['id'])
+                exercise_filepath = destination_filepath.joinpath(destination,'exercises', exercise_id)
+                thumbnails_filepath = exercise_filepath.joinpath('thumbnails')
+                thumbnails_filepath.mkdir(parents=True, exist_ok=True)
+                for i, image in enumerate(exercise['exercise']['thumbnails']):
+                    r = requests.get(image['image_filepath'])
+                    fname = image['image_filepath'].split('/')[-1]
+                    with thumbnails_filepath.joinpath(fname).open('wb') as f:
+                        f.write(r.content)
+
+                with exercise_filepath.joinpath(exercise_id).with_suffix('.json').open('w') as f:
+                    json.dump(exercise, f)
+
+                with exercise_filepath.joinpath(exercise_id).with_suffix('.txt').open('w') as f:
+                    f.write(exercise['name'])
+
+                if exercise["exercise"]["video_file"]:
+                    with exercise_filepath.joinpath('video_file').with_suffix('.m3u8').open('wb') as f:
+                        try:
+                            r = requests.get("http:"+exercise["exercise"]["video_file"])
+                        except:
+                            pass
+                        f.write(r.content)
+
+                with exercise_filepath.joinpath('description').with_suffix('.html').open('w') as f:
+                    f.write(exercise["exercise"]["description"])
+
+
+            with episode_filepath.joinpath(episode_id).with_suffix('.json').open('w') as f:
+                json.dump(episode, fp=f)
+
+        return
+
+if __name__ == "__main__":
+    pass