fli_video 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bfc30a6f56a497cc47ce80f0e2c09090b83abedf8586aedac879208512577a4
-  data.tar.gz: 011af4a5c4fda0c15209e0b9fc2b799b91d05dde3ebd5450b70c0e364b724e0d
+  metadata.gz: 3f8eeca7da2f46b1cd391df1040ded562b42a9125bb73966f404b1e221f7f6e7
+  data.tar.gz: e99e385feffbdb307d076a344e36b630807b40ec3b8ee1017a784e0866c8d5d3
 SHA512:
-  metadata.gz: 9cba026b1099cdbf9c8b1be009c22570f5160a608b098e1dd7539332d347dd47034cf25d942c951fcfe8d126ec1a26034ccbb3ac57d3bac089bdd2e6a02d95d2
-  data.tar.gz: 6b82f13326684e05659ccfc244e5c4a49a8af7f75b695cca1378cf33891f378c94870d0fe4faedbe6f38a1d9debcf1cf535d7e84413cd87447b81e794d686227
+  metadata.gz: aab6ec36d5b3cbe6bdb5c5fa598fa060af9ae618f2b9dc2d1fb07ad7dd06cce9b04c3fe3122f86c7a5a90fbe0013e5a3f27d4d6c7272684438c951fb738c8c9b
+  data.tar.gz: 0521d407ee628afd67a31f58f72ad8b69cfed61ce8f43a57d8d53bddd4dd2344e6ff5cc5be355dea172e27edd702ea2f8a3cdf4ca91bcb633a751ef87ca2f53a

data/.builders/klues/add_episode.klue

@@ -0,0 +1,25 @@
+component :add_episode do
+  desc "Add a new episode to an existing podcast project."
+
+  pattern "Interactor"
+
+  comments <<~TEXT
+    - Facilitates the addition of a new episode to a specific podcast project.
+    - Requires the project code of the podcast to ensure correct association.
+    - Allows setting of episode-specific details like episode code and name.
+    - Ensures that the episode is added only to podcast projects and not to other project types.
+    - Will create recording, chapter and support folders for the episode.
+  TEXT
+
+  method :run(:project_code, :episode_code, :episode_name)
+
+  sample :add_episode_to_podcast, <<~RUBY
+    # Add a new episode to existing podcast folder
+    add_episode.run('a21', '01', 'Episode About Something')
+    # Create:
+    # ~/video-projects/a21-ac-some-podcast/01-episode-about-something/assets
+    # ~/video-projects/a21-ac-some-podcast/01-episode-about-something/chapters
+    # ~/video-projects/a21-ac-some-podcast/01-episode-about-something/recordings
+    # ~/video-projects/a21-ac-some-podcast/01-episode-about-something/.trash
+  RUBY
+end

data/.builders/klues/change_chapter_name.klue

@@ -0,0 +1,32 @@
+component :change_chapter_name do
+  desc "Alter the name of a chapter based on its sequence in the project, facilitating better organization and identification of video content."
+
+  pattern "Command"
+  note "This should be a method on the project"
+
+  comments <<~TEXT
+    - Allows the renaming of a chapter within a video project.
+    - Utilizes the chapter's sequence number to identify and target the specific chapter for renaming.
+  TEXT
+
+  method :rename_chapter(:parent, :chapter_sequence, :new_name)
+
+  <<~FILE_SYSTEM
+    01-a-introduction-GPTIMPROVE.mov
+    01-b-introduction-more-content.mov
+    01-c-introduction.mov
+    01-d-introduction-CTA.mov
+    02-a-overview.mov
+    03-a-scenario-TITLE.mov
+  FILE_SYSTEM
+
+  sample :change_chapter_name_in_project, <<~RUBY
+    # Example of changing the name of a specific chapter in a project
+    change_chapter_name.rename_chapter('a27', '01', 'intro')
+
+    # 01-a-intro-GPTIMPROVE.mov
+    # 01-b-intro.mov
+    # 01-c-intro.mov
+    # 01-d-intro-CTA.mov
+  RUBY
+end

data/.builders/klues/create_chapter_video.klue

@@ -0,0 +1,34 @@
+component :create_chapter_video do
+  desc "Combine and all video parts for a chapter sequence and put into the chapters folder."
+
+  pattern "Command"
+
+  comments <<~TEXT
+    - Combines individual video segments into a single chapter video.
+    - Facilitates independent review and editing of each chapter.
+  TEXT
+
+  constructor(:parent_project)
+
+  method :run(:chapter_seq)
+
+  sample :create_chapter_video, <<~RUBY
+    project_path = ProjectPath.new('a27')
+
+    # Instantiate the component with the parent project
+    create_chapter_video = generate_chapter_video.new(project_path)
+
+    # Automatically combine all video segments for a chapter
+    create_chapter_video.run(1)
+    # Output: '~/video-projects/a27-ac-some-podcast/chapters/01-complete-chapter.mov'
+  RUBY
+
+  sample :create_chapter_video_for_segments, <<~RUBY
+    project_path = ProjectPath.new('a27')
+
+    create_chapter_video = generate_chapter_video.new(project_path)
+
+    create_chapter_video.run(1, ['01-intro-a.mov', '02-intro-b.mov'], output_file_name: '01-intro-custom.mov')
+    # Output: '~/video-projects/a27-ac-some-podcast/chapters/01-intro-custom.mov'
+  RUBY
+end

data/.builders/klues/create_project.klue

@@ -0,0 +1,37 @@
+component :create_project do
+  desc "Setup a new video project for standalone YouTube video or Podcast."
+
+  pattern "Interactor"
+
+  comments <<~TEXT
+    - Allows the creation of a new project, specifying if it's for a YouTube video or a Podcast.
+    - For YouTube videos, the project will be single-episode based.
+    - For Podcasts, the project can include multiple episodes.
+    - Stores project-specific settings and metadata.
+    - Will create recording, chapter and support folders for project_type: video
+  TEXT
+
+  enum :project_type, %w(video podcast)
+
+  method :run(:project_type, :project_code, :channel_code, :project_name)
+
+  sample :new_video_project, <<~RUBY
+    # Create a new video project for AppyDave
+    create_project.run(:video, 'a20', 'ad', 'Some Video')
+    # Create: 
+    # ~/video-projects/a20-ad-some-video
+    # ~/video-projects/a20-ad-some-video/.fv.json
+    # ~/video-projects/a20-ad-some-video/assets
+    # ~/video-projects/a20-ad-some-video/chapters
+    # ~/video-projects/a20-ad-some-video/recordings
+    # ~/video-projects/a20-ad-some-video/.trash
+  RUBY
+
+  sample :new_podcast_project, <<~RUBY
+    # Create a new podcast project for AppyCast
+    create_project.run(:podcast, 'a21', 'ac', 'Some Podcast')
+    # Creates folder:
+    # ~/video-projects/a21-ac-some-podcast
+    # ~/video-projects/a21-ac-some-podcast/.fv.json
+    RUBY
+end

data/.builders/klues/empty_trash.klue

@@ -0,0 +1,24 @@
+component :empty_trash do
+  desc "Permanently delete video takes from the '.trash' folder."
+
+  pattern "Command"
+
+  comments <<~TEXT
+    - Permanently removes all recordings from the trash folder.
+    - Frees up storage space by deleting unnecessary files.
+    - Maintains project clarity by clearing clutter.
+    - Ensures that only unwanted takes are deleted after a final review.
+  TEXT
+
+  constructor(:parent_project)
+
+  method :run
+
+  sample :permanently_delete_trash, <<~RUBY
+    project_path = ProjectPath.new('a27')
+    
+    # Permanently deleting all contents of the trash folder
+    clean_trash.empty_trash
+    # Empties the entire .trash folder in "~/video-projects/a27-ac-categorize-mp4-CI/.trash/
+  RUBY
+end

data/.builders/klues/episode_path.klue

@@ -0,0 +1,77 @@
+component :episode_path do
+  desc "Construct episode path using project/episode code and deducing state based on existing folder name."
+
+  pattern "Adapter"
+
+  comments <<~TEXT
+    - Infers episode path based on episode code and existing folder name.
+    - Maintains state for episode code and descriptive name and keywords.
+    - Will use current project code if not provided.
+    - Path is relative to project path.
+    - Uses existing folder name and keywords to build internal state.
+    - Provides method for building absolute, relative and sub folder.
+    - Provides method for building a new path for rename operations.
+    - Provides access to associated project.
+    - Stores state in an internal data object.
+    - Designed for building folder names, not create or modify actual directories.
+    TEXT
+
+  accessors :episode_code, :episode_name, :keywords, :episode_path, :project
+
+  method :constructor(:episode_code, episode_name: nil, keywords: nil, project_code: nil)
+  method :instance(:folder)
+
+  method :change_path(episode_code: nil, episode_name: nil, keywords: nil)
+
+  # project_path.recording_path # => "~/video-projects/a27-ac-categorize-mp4-CI/recordings"
+                                    # ~/video-projects/a27-ac-categorize-mp4-CI/01-flivideo-project-kickoff-TODO/recordings
+
+  sample :create_episode_path, <<~RUBY
+    # Create a new episode path
+    episode_path = EpisodePath.new('01', episode_name: 'flivideo-project-kickoff', keywords: ['TODO'] )
+    episode_path.episode_path # => "~/video-projects/a27-ac-categorize-mp4-CI/01-flivideo-project-kickoff-TODO"
+    episode_path.episode_code # => "01"
+    episode_path.episode_name # => "flivideo-project-kickoff"
+    episode_path.keywords # => ["TODO"]
+
+    project_path = episode_path.project
+    project_path.project_path # => "~/video-projects/a27-ac-categorize-mp4-CI"
+  RUBY
+
+  sample :infer_episode_path, <<~RUBY
+    # Infer episode path based on episode code and existing folder
+    episode_path = EpisodePath.new('01')
+    episode_path.episode_path # => "~/video-projects/a27-ac-categorize-mp4-CI/01-flivideo-project-kickoff-TODO"
+    episode_path.episode_code # => "01"
+    episode_path.episode_name # => "flivideo-project-kickoff"
+    episode_path.keywords # => ["TODO"]
+
+  RUBY
+
+  sample :rename_episode_path, <<~RUBY
+    # Rename episode path
+    episode1 = EpisodePath.new('01')
+    episode1.episode_path # => "~/video-projects/a27-ac-categorize-mp4-CI/01-flivideo-project-kickoff-TODO"
+
+    episode2 = episode1.change_path(episode_code: '02')
+    episode2.episode_path # => "~/video-projects/a27-ac-categorize-mp4-CI/02-flivideo-project-kickoff-TODO"
+
+    episode3 = episode1.change_path(episode_code: '03', episode_name: 'build-gpts', keywords: [])
+    episode3.episode_path # => "~/video-projects/a27-ac-categorize-mp4-CI/03-build-gpts"
+  RUBY
+
+  sample :next_episode_code, <<~RUBY
+    # Get next episode code
+    episode_path = EpisodePath.new('01')
+    episode_path.next_episode_code # => "02"
+  RUBY
+
+  sample :folder_to_episode_path, <<~RUBY
+    # Convert folder to episode path
+    episode_path = EpisodePath.instance('~/video-projects/a27-ac-categorize-mp4-CI/01-flivideo-project-kickoff-TODO')
+    episode_path.episode_path # => "~/video-projects/a27-ac-categorize-mp4-CI/01-flivideo-project-kickoff-TODO"
+    episode_path.episode_code # => "01"
+    episode_path.episode_name # => "flivideo-project-kickoff"
+    episode_path.keywords # => ["TODO"]
+  RUBY
+end

data/.builders/klues/global_config.klue

@@ -0,0 +1,31 @@
+component :global_configuation do
+  pattern "Singleton"
+
+  desc "Access and apply global configuration settings for video asset management and state consistency."
+
+  comments <<~TEXT
+    Configuration file path: ~/.fli-video.json
+    - Automatically creates a configuration file if it does not exist.
+    - Responsible for reading and updating global configuration.
+    - Provides methods to manage folder paths and various settings.
+  TEXT
+
+  sample :configuration, <<~JSON
+  {
+    "folders": {
+      "ecamm-recordings": "~/Movies/Ecamm Live Recordings",
+      "project-root": "/Volumes/Expansion/Sync/tube-channels/a-cast/cast-active",
+    },
+    "settings": {
+      "focus-project-code": "a27",
+    },
+  }
+  JSON
+
+  method :set_folder(:key, :folder)
+  method :folder(:key)
+  method :set_setting(:key, :value)
+  method :setting(:key)
+  method :load
+  method :save
+end

data/.builders/klues/move_ecamm_file.klue

@@ -0,0 +1,21 @@
+component :move_ecamm_file do
+  desc "Seamlessly transfer eCamm recordings to the current focused video or podcast episode recordings subfolder."
+
+  comments <<~TEXT
+    - Facilitates the transfer of eCamm recording files to the appropriate project's recording subfolder.
+    - Automatically identifies the current focused project or episode to ensure correct file placement.
+    - Handles the file transfer process, maintaining file integrity and updating any necessary metadata.
+    - Uses global configuration to determine eCamm recording folder location.
+    - Uses current project configuration to determine recording subfolder location.
+    - Aborts the transfer process if target folder does not exist.
+  TEXT
+
+  method :execute(:ecamm_file_name)
+
+  sample :move_ecamm_file_to_project, <<~RUBY
+    # Move an eCamm recording to the currently focused project's recordings subfolder
+    move_ecamm_file.execute('Ecamm Live Recording on 2023-08-25 at 14.51.58.mov')
+
+    # ~/video-projects/a20-ad-some-video/recordings/Ecamm Live Recording on 2023-08-25 at 14.51.58.mov
+  RUBY
+end

data/.builders/klues/move_to_trash.klue

@@ -0,0 +1,29 @@
+component :move_to_trash do
+  desc "Move suboptimal video takes to '.trash' folder"
+
+  pattern "Command"
+
+  comments <<~TEXT
+    - Will trash a specific recording in a project folder.
+    - Will identify the last eCamm recording in a project folder if no specific recording is provided.
+    - Enhances project clarity and organization.
+  TEXT
+
+  constructure(:parent_project)
+
+  method :run(:file_name)
+
+  sample :move_video_to_trash, <<~RUBY
+    project_path = ProjectPath.new('a27')
+
+    command = move_to_trash.new(project_path)
+  
+    # Example of moving a specific suboptimal video take to the trash folder
+    command.run('01-a-introduction.mov')
+    # => "~/video-projects/a27-ac-categorize-mp4-CI/.trash/01-a-introduction.mov"
+
+    # Example of moving the last suboptimal video take to the trash folder
+    command.run
+    # => "~/video-projects/a27-ac-categorize-mp4-CI/.trash/Ecamm Live Recording on 2023-08-25 at 14.51.58.mov
+  RUBY
+end

data/.builders/klues/open_in_finder.klue

@@ -0,0 +1,25 @@
+component :open_in_finder do
+  desc "Quickly access video project and episode folders within the Finder."
+
+  pattern "Command"
+
+  comments <<~TEXT
+    - Provides shortcuts to open project and episode folders in the Finder.
+    - Enhances efficiency in navigating to specific video project locations.
+    - Streamlines the process of locating and managing video files and folders.
+  TEXT
+
+  constructor(:parent_project)
+
+  method :run
+
+  sample :access_project_in_finder, <<~RUBY
+    project_path = ProjectPath.new('a27')
+
+    command = open_in_finder.new(project_path)
+    # Opens the folder for project 'a27' in Finder
+
+    command.run
+    # Opens the folder for episode '01' of project 'a27' in Finder
+  RUBY
+end

data/.builders/klues/project_config.klue

@@ -0,0 +1,123 @@
+component :project_configuration do
+  desc "Manage project / episode settings and state."
+
+  pattern "Adapter"
+
+  comments <<~TEXT
+    Configuration file: .fv.json
+    - Handles settings for single videos or the episodes in a Podcast.
+    - Responsible for reading and updating settings.
+    - Supports state management for single video, episodes, recording and chapter progression.
+    - This class is a reflection of the configuration file and the folders and files it manages.
+
+    Project type: video
+    - A single video file.
+    - Supports recording and chapter progression
+
+    Project type: podcast
+    - Multiple video files known as episodes.
+    - Supports recording and chapter progression for each episode.
+
+    Infers project type from the presence of the "episodes" key.
+    Infers project name from the name of the folder containing the configuration file.
+    Infers episode name from the name of the folder containing the video file.
+    Keeps track of prefered chapter name for each chapter sequence.
+  TEXT
+
+  method :load
+  method :save
+  method :resync_project_files()        # refreshes the configuration based on the file system
+  method :current_chapter()             # if type == :video
+  method :current_episode()             # if type == :podcast
+
+  data_object :project_config do
+    constructor(:json)
+
+    attribute :type                     # video, podcast
+    attribute :code
+    attribute :chapters                 # if type == :video
+    attribute :episodes                 # if type == :podcast
+  end
+
+  data_object :episode_config do
+    constructor(:json)
+
+    attribute :seq                      # episode number store as number, but displayed as 2 digit string
+    attribute :chapters
+    attribute :current                  # true if this is the current episode
+
+    method :current_chapter()
+  end
+
+  data_object :chapter_config do
+    constructor(:json)
+
+    attribute :seq
+    attribute :preferred_name
+    attribute :current                  # true if this is the current chapter
+  end
+
+  sample :configuration, :for_video, <<~JSON
+  {
+    "type": "video",
+    "code": "e28",
+    "chapters": [
+      {
+        seq: 1,
+        preferred_name: "intro"
+      },
+      {
+        seq: 2,
+        preferred_name: "example"
+      },
+      {
+        seq: 3,
+        preferred_name: "outro",
+        current: true
+      }
+    ]
+  }
+  JSON
+
+  sample :configuration, :for_podcast, <<~JSON
+  {
+    "type": "podcast",
+    "code": "e27",
+    "episodes": [
+      {
+        "seq": 1,
+        "chapters": [
+          {
+            "seq": 1,
+            "preferred_name": "introduction",
+          },
+          {
+            "seq": 2,
+            "preferred_name": "scenario",
+            "current": true
+          }
+        ]
+      },
+      {
+        "seq": 2,
+        "current": true,
+        "chapters": [
+          {
+            "seq": 1,
+            "preferred_name": "introduction",
+          },
+          {
+            "seq": 2,
+            "preferred_name": "scenario",
+          },
+          {
+            "seq": 3,
+            "preferred_name": "story",
+            "current": true
+          }
+        ]
+      }
+    ]
+  }
+  JSON
+end

data/.builders/klues/project_meta_data_store.klue

@@ -0,0 +1,28 @@
+component :project_meta_data_store do
+  desc "Build a JSON datastore of project files with inferred metadata."
+
+  pattern "Command"
+
+  comments <<~TEXT
+    - Aggregates file data from project, episode, recording, chapter, and post-produced folders.
+    - Infers metadata from sources like KEYWORDS, transcripts, and other relevant data.
+    - Creates a comprehensive JSON datastore for the entire project.
+    - Facilitates advanced data analysis and management for the project.
+    - The extracted data can be used for automated post-production processes like keyword generation, B-roll prompts, chapter names, title slides, and time code markers for calls to action.
+  TEXT
+
+  constructor(:parent_project)
+
+  method :run
+
+  sample :build_project_metadata, <<~RUBY
+    project_path = ProjectPath.new('a27')
+
+    # Instantiate the component with the parent project
+    metadata_store = project_meta_data_store.new(project_path)
+
+    # Execute the process to aggregate files and infer metadata
+    metadata_store.run
+    # Output: '~/video-projects/a27-ac-categorize-mp4-CI/project_metadata.json'
+    RUBY
+end

data/.builders/klues/project_path.klue

@@ -0,0 +1,77 @@
+component :project_path do
+  desc "Construct project path using project code and deducing state based on existing folder name."
+
+  pattern "Adapter"
+
+  comments <<~TEXT
+    - Infers project path based on project code and existing folder name.
+    - Maintains state for project code, channel code, descriptive name, keywords and episodes.
+    - Uses global configuration to determine root folder.
+    - Uses existing folder name and keywords to build internal state.
+    - Provides method for building absolute, relative and sub folder.
+    - Provides method for building new path for rename operations.
+    - Provides list of associated episode paths.
+    - Stores state in an internal data object.
+    - Designed for building folder names, not create or modify actual directories.
+  TEXT
+
+  accessors :project_code, :channel_code, :project_name, :keywords, :project_path, :episodes
+
+  method :constructor(:project_code, channel_code: nil, project_name: nil, keywords: nil)
+  method :instance(:folder)
+
+  method :change_path(project_code: nil, channel_code: nil, project_name: nil, keywords: nil)
+
+  sample :create_project_path, <<~RUBY
+    # Create a new project path
+    project_path = ProjectPath.new('a27', channel_code: 'ac', project_name: 'categorize-mp4', keywords: ['CI'] )
+    project_path.project_path # => "~/video-projects/a27-ac-categorize-mp4-CI"
+    project_path.project_code # => "a27"
+    project_path.channel_code # => "ac"
+    project_path.project_name # => "categorize-mp4"
+    project_path.keywords # => "CI"
+    project_path.episodes.count # => 0
+  RUBY
+
+  sample :infer_project_path, <<~RUBY
+    # Infer project path based on project code and existing folder
+    project_path = ProjectPath.new('a27')
+    project_path.project_path # => "~/video-projects/a27-ac-categorize-mp4-CI"
+    project_path.project_code # => "a27"
+    project_path.channel_code # => "ac"
+    project_path.project_name # => "categorize-mp4"
+    project_path.keywords # => "CI"
+    project_path.episodes.count # => 2
+  RUBY
+
+  sample :rename_project_path, <<~RUBY
+    # Rename project path
+    project_path = ProjectPath.new('a27')
+
+    path1 = project_path.change_path(project_code: 'a28')
+    path1.project_path # => "~/video-projects/a28-ac-categorize-mp4-CI"
+    path2 = project_path.change_path(channel_code: 'ad', project_name: 'categorize-mp4-for-appydave')
+    path2.project_path # => "~/video-projects/a27-ad-categorize-mp4-for-appydave-CI"
+    path3 = project_path.change_path(keywords: [])
+    path3.project_path # => "~/video-projects/a27-ac-categorize-mp4"
+  RUBY
+
+  sample :next_project_code, <<~RUBY
+    # Get next project code
+    project_path = ProjectPath.new('a27')
+    project_path.next_project_code # => "a28"
+
+    project_path = ProjectPath.new('a99')
+    project_path.next_project_code # => "b00"
+  RUBY
+
+  sample :folder_to_project_path, <<~RUBY
+    # Convert folder to project path
+    project_path = ProjectPath.instance('~/video-projects/a27-ac-categorize-mp4-CI')
+    project_path.project_path # => "~/video-projects/a27-ac-categorize-mp4-CI"
+    project_path.project_code # => "a27"
+    project_path.channel_code # => "ac"
+    project_path.project_name # => "categorize-mp4"
+    project_path.keywords # => "CI"
+  RUBY
+end

data/.builders/klues/recording_file_watcher.klue

@@ -0,0 +1,28 @@
+component :filewatch_processor do
+  desc "Automate file event responses, directing new recordings to current project folders."
+
+  pattern "Observer"
+
+  comments <<~TEXT
+    - Monitors new eCamm recordings file events.
+    - Automates the process of moving new recordings to specified project folders.
+    - Enhances content management by ensuring recordings are organized efficiently.
+    - Configurable to respond to different types of file events and target folders.
+  TEXT
+
+  method :watch(:folder_path, :event_type)
+
+  # Will move the file to current project's recordings folder
+  method :move_file
+
+  sample :automate_recording_organization, <<~RUBY
+    config = GlobalConfig.instance
+    
+    # Watch a specific folder for new and existing recordings
+    filewatch_processor.watch(config.folders['ecamm-recordings'], '*.mov', :moved_file)
+
+    # Example usage
+    # When a new file is detected in Ecamm Live Recordings, it is automatically moved to the current project's recordings folder.
+    filewatch_processor.move_file
+  RUBY
+end