vlcsync 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

vlcsync/cli.py

@@ -11,7 +11,8 @@ from vlcsync.syncer import AppConfig, Syncer
 from vlcsync.vlc_finder import print_exc
 from vlcsync.vlc_state import VlcId
 
-__version__ = "0.2.1"
+# Also ref in project.toml
+__version__ = "0.3.1"
 
 
 @click.command
@@ -28,20 +29,32 @@ __version__ = "0.2.1"
               required=False,
               is_flag=True,
               help="Disable discovery local vlc instances.")
-def main(rc_host_list: Set[VlcId], no_local_discover):
+@click.option("--volume-sync",
+              "volume_sync",
+              default=False,
+              required=False,
+              is_flag=True,
+              help=
+              """
+              Enable volume sync between players. Useful for play video with external audio file.\n
+              I.e. first play video with disabled audio track ('vlc --no-audio video.mkv' option) and then play audio stream (`vlc audio.mka`).
+              \n  
+              And you can control volume from main video player.
+              """)
+def main(rc_host_list: Set[VlcId], no_local_discover, volume_sync):
     """Utility for synchronize multiple instances of VLC. Supports seek, play and pause."""
-    print("Vlcsync started...")
+    print("Vlcsync started...", flush=True)
 
-    app_config = AppConfig(rc_host_list, no_local_discover)
+    app_config = AppConfig(rc_host_list, no_local_discover, volume_sync)
     time.sleep(2)  # Wait instances
     while True:
         try:
             with Syncer(app_config) as s:
                 while True:
-                    s.do_sync()
+                    s.do_check_synchronized()
                     time.sleep(0.05)
         except KeyboardInterrupt:
             sys.exit(0)
         except Exception:
             print_exc()
-            print("Exception detected. Restart sync...")
+            print("Exception detected. Restart sync...", flush=True)

vlcsync/syncer.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 import sys
 import time
-from typing import Set
+from typing import Set, List
 
 from loguru import logger
 
-from vlcsync.vlc import VLC_IFACE_IP, VlcProcs
+from vlcsync.vlc import VLC_IFACE_IP, VlcProcs, Vlc
 from vlcsync.vlc_finder import LocalProcessFinderProvider, ExtraHostFinder
 from vlcsync.vlc_socket import VlcConnectionError
 
@@ -18,6 +18,7 @@ from vlcsync.vlc_state import VlcId
 class AppConfig:
     extra_rc_hosts: Set[VlcId]
     no_local_discovery: bool
+    volume_sync: bool
 
 
 class Syncer:
@@ -29,48 +30,77 @@ class Syncer:
         vlc_finders = set()
         if not self.app_config.no_local_discovery:
             vlc_finders.add(LocalProcessFinderProvider(VLC_IFACE_IP))
-            print(f"  Discover instances on {VLC_IFACE_IP} iface...")
+            print(f"  Discover instances on {VLC_IFACE_IP} iface...", flush=True)
         else:
-            print("  Local discovery vlc instances DISABLED...")
+            print("  Local discovery vlc instances DISABLED...", flush=True)
 
         if app_config.extra_rc_hosts:
             vlc_finders.add(ExtraHostFinder(app_config.extra_rc_hosts))
             for rc_host in app_config.extra_rc_hosts:
                 rc_host: VlcId
-                print(f"  Manual host defined {rc_host.addr}:{rc_host.port}")
+                print(f"  Manual host defined {rc_host.addr}:{rc_host.port}", flush=True)
         else:
-            print("""  Manual vlc addresses ("--rc-host" args) NOT provided...""")
+            print("""  Manual vlc addresses ("--rc-host" args) NOT provided...""", flush=True)
 
         if not vlc_finders:
             print("\nTarget vlc instances not selected (nor autodiscover, nor manually). \n"
-                  """See: "vlcsync --help" for more info""")
+                  """See: "vlcsync --help" for more info""", flush=True)
             sys.exit(1)
 
         self.env = VlcProcs(vlc_finders)
 
     def __enter__(self):
-        self.do_sync()
+        self.do_check_synchronized()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-    def do_sync(self):
-        self.log_with_debounce("Sync...")
+    def do_check_synchronized(self):
+        self.log_with_debounce("do_check_synchronized()...")
         try:
-            for vlc_id, vlc in self.env.all_vlc.items():
-                is_changed, state = vlc.is_state_change()
-                if not state.is_active():
-                    continue
+            if self.app_config.volume_sync:
+                self.sync_volume()
 
-                if is_changed:
-                    print(f"\nVlc state change detected from ({vlc_id})")
-                    self.env.sync_all(state, vlc)
-                    return
+            self.sync_playstate()
 
         except VlcConnectionError as e:
             self.env.dereg(e.vlc_id)
 
+    def sync_playstate(self):
+        for vlc_id, vlc in self.env.all_vlc.items():
+            is_changed, state, playlist_changed = vlc.is_state_change()
+
+            if is_changed:
+                # Workaround Save volumes.
+                # When playlist items changed ALSO happen volumes sync by some reason. But SHOULD NOT!
+                volumes: List[tuple[Vlc, int]] = []
+                if not self.app_config.volume_sync and playlist_changed:
+                    volumes = [(vlc1, vlc1.volume()) for _, vlc1 in self.env.all_vlc.items()]
+                #
+
+                print(f"\nVlc state change detected from ({vlc_id})", flush=True)
+                self.env.sync_all(state, vlc)
+
+                # Restore volumes if needed
+                if volumes:
+                    for vlc_next, volume in volumes:
+                        vlc_next.set_volume(volume)
+                # Trying to fix endless resyncing hang
+                # Cannot find reproduce steps for that
+                time.sleep(0.5)
+                break
+
+    def sync_volume(self):
+        for vlc_id, vlc in self.env.all_vlc.items():
+            cur_volume = vlc.volume()
+            if vlc.prev_volume != cur_volume:
+                for vlc_id_for_sync, vlc_for_sync in self.env.all_vlc.items():
+                    vlc_for_sync.prev_volume = cur_volume
+                    if vlc_for_sync != vlc:
+                        vlc_for_sync.set_volume(cur_volume)
+                break
+
     def log_with_debounce(self, msg: str, _debounce=5):
         if time.time() > self.supress_log_until:
             logger.debug(msg)

vlcsync/vlc.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
+from functools import lru_cache
+import re
 import socket
 import threading
 import time
-from typing import Set
+from typing import Set, List, Optional
 
 from loguru import logger
 
 from vlcsync.vlc_finder import IVlcListFinder
 from vlcsync.vlc_socket import VlcSocket
-from vlcsync.vlc_state import PlayState, State, VlcId
+from vlcsync.vlc_state import PlayState, State, VlcId, PlayList, PlayListItem
 
 VLC_IFACE_IP = "127.0.0.42"
+RE_PLAYSTATE_COMPILED = re.compile(r"\( state (playing|stopped|paused) \)")
+RE_PLAYLIST_ITEM = re.compile(r'\| {2}([ *])(\d+) - ')
 
 socket.setdefaulttimeout(0.5)
 
@@ -21,67 +25,139 @@ class Vlc:
         self.vlc_id = vlc_id
         self.vlc_conn = VlcSocket(vlc_id)
         self.prev_state: State = self.cur_state()
+        self.prev_volume = self.volume()
 
     def play_state(self) -> PlayState:
         status = self.vlc_conn.cmd("status")
         return self._extract_state(status)
 
-    def get_time(self) -> int | None:
+    def get_seek(self) -> int | None:
         seek = self.vlc_conn.cmd("get_time")
         if seek != '':
             return int(seek)
 
+    def playlist_goto(self, vlc_internal_index: int):
+        self.vlc_conn.cmd(f"goto {vlc_internal_index}")
+
+    def playlist(self) -> PlayList:
+        cmd_resp = self.vlc_conn.cmd("playlist")
+        return self._extract_playlist(cmd_resp)
+
+    def volume(self) -> Optional[int]:
+        vol = self.vlc_conn.cmd("volume")
+        if vol.strip() != '':
+            return int(float(vol.replace(",",'.')))
+        else:
+            return None
+
+    def set_volume(self, volume: int):
+        self.vlc_conn.cmd(f"volume {volume}")
+        self.prev_volume = volume
+
     def seek(self, seek: int):
         self.vlc_conn.cmd(f"seek {seek}")
 
+    def stop(self):
+        self.vlc_conn.cmd("stop")
+
+    def pause(self):
+        self.vlc_conn.cmd("pause")
+
+    def play(self):
+        self.vlc_conn.cmd("play")
+
     def cur_state(self) -> State:
-        get_time = self.get_time()
+        cur_seek = self.get_seek()
 
         return State(self.play_state(),
-                     get_time,
-                     time.time() - (get_time or 0))
+                     cur_seek,
+                     self.playlist().active_order_index(),
+                     # Abs time of video start
+                     time.time() - (cur_seek or 0)
+                     )
 
     def is_state_change(self) -> (bool, State):
         cur_state: State = self.cur_state()
         prev_state: State = self.prev_state
-        is_change = not cur_state.same(prev_state)
+        full_same, playlist_same = cur_state.same(prev_state)
 
         # Return cur_state for reduce further socket communications
-        return is_change, cur_state
+        return not full_same, cur_state, not playlist_same
 
     def sync_to(self, new_state: State, source: Vlc):
-        if not new_state.is_active():
-            return
-
-        cur_play_state = self.play_state()
 
-        if cur_play_state != new_state.play_state:
-            self.play_if_pause(new_state, cur_play_state)
-            self.pause_if_play(new_state, cur_play_state)
-
-        # Sync all secondary, but main only when playing
-        if source != self or cur_play_state == PlayState.PLAYING:
-            self.seek(new_state.seek)
+        self._sync_playlist(new_state)
+        self._sync_playstate(new_state)
+        self._sync_timeline(new_state, source)
 
         self.prev_state = self.cur_state()
 
-    def pause_if_play(self, new_state, cur_play_state):
-        if cur_play_state == PlayState.PLAYING and new_state.play_state == PlayState.PAUSED:
-            self.vlc_conn.cmd("pause")
+    def _sync_timeline(self, new_state: State, source: Vlc):
+        cur_play_state = self.play_state()
+
+        if cur_play_state == PlayState.PAUSED and source == self:
+            """
+            Skip sync seek with himself on pause (avoid flickering)
+            As half-seconds not supported and cannot to set.
+            """
+            pass
+        else:
+            # In all other cases
+            self.seek(new_state.seek)
 
-    def play_if_pause(self, new_state, cur_play_state):
-        if cur_play_state == PlayState.PAUSED and new_state.play_state == PlayState.PLAYING:
-            self.vlc_conn.cmd("play")
+    def _sync_playstate(self, new_state: State):
+        cur_play_state: PlayState = self.play_state()
+        if cur_play_state != new_state.play_state:
+            if new_state.play_state == PlayState.STOPPED:
+                self.stop()
+            elif new_state.play_state == PlayState.PLAYING:
+                if cur_play_state in [PlayState.PAUSED, PlayState.STOPPED]:
+                    self.play()
+            elif new_state.play_state == PlayState.PAUSED:
+                if cur_play_state == PlayState.PLAYING:
+                    self.pause()
+            else:
+                logger.warning(f"Unknown new play state {new_state.play_state} for player")
+
+    def _sync_playlist(self, new_state: State):
+        cur_playlist = self.playlist()
+        if new_state.is_play_or_pause() and cur_playlist.active_order_index() != new_state.playlist_order_idx:
+            if new_state.playlist_order_idx is not None and len(cur_playlist.items) > new_state.playlist_order_idx:
+                self.playlist_goto(cur_playlist.items[new_state.playlist_order_idx].vlc_internal_index)
+            else:
+                self.stop()
 
     @staticmethod
-    def _extract_state(status, _valid_states=(PlayState.PLAYING.value,
-                                              PlayState.PAUSED.value,
-                                              PlayState.STOPPED.value)):
-        for pb_state in _valid_states:
-            if pb_state in status:
-                return PlayState(pb_state)
+    @lru_cache(maxsize=128)
+    def _extract_state(status: str):
+        match = RE_PLAYSTATE_COMPILED.search(status)
+        return PlayState(match.group(1)) if match else PlayState.UNKNOWN
 
-        return PlayState.UNKNOWN
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def _extract_playlist(resp: str) -> PlayList:
+        """ Playlist answer Format:
+        +----[ Playlist - playlist ]
+        | 1 - Плейлист
+        |   6 - Video 1.mkv (00:23:37) [played 1 time]
+        |  *4 - Video 2.mkv (00:23:44) [played 2 times]
+        |   3 - Video 3.mkv (00:23:43) [played 1 time]
+        |   5 - Video 4.mkv (00:23:44) [played 1 time]
+        | 2 - Медиатека
+        |   12 - Video 6.mkv (00:23:44)
+        +----[ End of playlist ]
+        """
+
+        items: List[PlayListItem] = []
+        active: Optional[PlayListItem] = None
+
+        for idx, match in enumerate(re.finditer(RE_PLAYLIST_ITEM, resp)):
+            item = PlayListItem(idx, match.group(2))
+            items.append(item)
+            if match.group(1) == "*":
+                active = item
+
+        return PlayList(items, active)
 
     def __repr__(self):
         return f"Vlc({self.vlc_id}, {self.prev_state=})"
@@ -119,7 +195,7 @@ class VlcProcs:
             for vlc_id in vlc_candidates:
                 if vlc_id not in self._vlc_instances.keys():
                     if vlc := self.try_connect(vlc_id):
-                        print(f"Found active instance {vlc_id}, with state {vlc.cur_state()}")
+                        print(f"Found active instance {vlc_id}, with state {vlc.cur_state()}", flush=True)
                         self._vlc_instances[vlc_id] = vlc
 
             logger.debug(f"Compute all_vlc (took {time.time() - start:.3f})...")
@@ -131,35 +207,31 @@ class VlcProcs:
             return Vlc(vlc_id)
         except Exception as e:
             logger.opt(exception=True).debug("Cannot connect to {0}, cause: {1}", vlc_id, e)
-            print(f"Cannot connect to {vlc_id} socket, cause: {e}. Skipping. Enable debug for more info. See --help. ")
+            print(f"Cannot connect to {vlc_id} socket, cause: {e}. Skipping. Enable debug for more info. See --help. ", flush=True)
             return None
 
     @property
     def all_vlc(self) -> dict[VlcId, Vlc]:
         return self._vlc_instances.copy()  # copy: for thread safe
 
-    def sync_all(self, state: State, source: Vlc):
+    def sync_all(self, state: State, source_vlc: Vlc):
         logger.debug(">" * 60)
-        logger.debug(f"Detect change to {state} from {source.vlc_id}")
-        logger.debug(f" old --> {source.prev_state} ")
+        logger.debug(f"Detect change to {state} from {source_vlc.vlc_id}")
+        logger.debug(f" old --> {source_vlc.prev_state} ")
         logger.debug(f" new --> {state} ")
-        logger.debug(f" Time diff abs(old - new) {abs(state.time_diff - source.prev_state.time_diff)}")
+        logger.debug(f" Time diff abs(old - new) {abs(source_vlc.prev_state.vid_start_at - state.vid_start_at)}")
         logger.debug("<" * 60)
         logger.debug("")
-        print(">>> Sync windows...")
-        if not state.is_active():
-            print("   Source window stopped. Skip sync")
-            return
+        print(">>> Sync players...", flush=True)
 
         for next_pid, next_vlc in self.all_vlc.items():
             next_vlc: Vlc
-            if next_vlc.cur_state().is_active():
-                print(f"    Sync {next_pid} to {state}")
-                next_vlc.sync_to(state, source)
+            print(f"    Sync {next_pid} to {state}", flush=True)
+            next_vlc.sync_to(state, source_vlc)
         print()
 
     def dereg(self, vlc_id: VlcId):
-        print(f"Detect vlc instance closed {vlc_id}")
+        print(f"Detect vlc instance closed {vlc_id}", flush=True)
         if vlc_to_close := self._vlc_instances.pop(vlc_id, None):
             vlc_to_close.close()
 
@@ -172,5 +244,3 @@ class VlcProcs:
 
     def __del__(self):
         self.close()
-
-

vlcsync/vlc_finder.py

@@ -28,16 +28,16 @@ class IVlcListFinder:
 
 
 class LocalProcessFinderProvider(IVlcListFinder):
-    def __init__(self, iface):
-        self.iface = iface
+    def __init__(self, iface: str):
+        self._iface = iface
 
     def get_vlc_list(self) -> Set[VlcId]:
         vlc_ports = set()
 
         for proc in self._find_vlc_procs():
-            port = self._has_listen_port(proc, self.iface)
+            port = self._has_listen_port(proc, self._iface)
             if port:
-                vlc_ports.add(VlcId(self.iface, port, proc.pid))
+                vlc_ports.add(VlcId(self._iface, port, proc.pid))
 
         return vlc_ports
 
@@ -90,11 +90,12 @@ class LocalProcessFinderProvider(IVlcListFinder):
 
 def print_exc():
     print("-" * 60)
-    print("Exception in user code: ")
+    print("Exception in user code: ", flush=True)
     print("-" * 60)
     traceback.print_exc(file=sys.stdout)
     print("-" * 60)
     print()
+    sys.stdout.flush()
 
 
 class ExtraHostFinder(IVlcListFinder):

vlcsync/vlc_state.py

@@ -38,16 +38,23 @@ class PlayState(Enum):
 class State:
     play_state: PlayState
     seek: int
-    time_diff: float = field(repr=False)
+    playlist_order_idx: int
+    """
+    vid_start_at - is abs time of video start in given vlc
+    
+    If this time changed it indicates time seek 
+    
+    See for details:
+       - play_in_same_pos()
+       - Vlc.cur_state() 
+    """
+    vid_start_at: float = field(repr=False)
 
     def same(self, other: State):
-        return (self.same_play_state(other) and
-                (
-                        self.play_in_same_pos(other) or
-                        self.pause_is_same_pos(other) or
-                        self.both_stopped(other)
-                )
-                )
+        playlist_same = self.same_playlist_item(other)
+        full_same = (self.same_play_state(other) and playlist_same and (
+                    self.play_in_same_pos(other) or self.pause_is_same_pos(other) or self.both_stopped(other)))
+        return full_same, playlist_same
 
     def same_play_state(self, other: State):
         return self.play_state == other.play_state
@@ -57,23 +64,41 @@ class State:
 
     def play_in_same_pos(self: State, other: State):
         """ Check time_diff only when play """
-        desync_secs = abs(self.time_diff - other.time_diff)
+        desync_secs = abs(self.vid_start_at - other.vid_start_at)
 
         if 2 < desync_secs < MAX_DESYNC_SECONDS:
             logger.debug(f"Asynchronous anomaly between probes: {desync_secs} secs")
 
         return (
                 self.play_state == other.play_state == PlayState.PLAYING and
-                self.time_diff and other.time_diff and
+                self.vid_start_at and other.vid_start_at and
                 desync_secs < MAX_DESYNC_SECONDS
         )
 
     def both_stopped(self, other: State):
         return self.play_state == other.play_state == PlayState.STOPPED
 
-    def is_active(self):
+    def is_play_or_pause(self):
         return self.play_state in [PlayState.PLAYING, PlayState.PAUSED]
 
+    def same_playlist_item(self, other):
+        return self.playlist_order_idx == other.playlist_order_idx
+
+
+@dataclass
+class PlayListItem:
+    order_index: int
+    vlc_internal_index: int
+
+
+@dataclass
+class PlayList:
+    items: List[PlayListItem]
+    active_item: Optional[PlayListItem]
+
+    def active_order_index(self) -> Optional[int]:
+        return self.active_item.order_index if self.active_item else None
+
 
 @dataclass(frozen=True)
 class VlcId:

{vlcsync-0.2.1.dist-info → vlcsync-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vlcsync
-Version: 0.2.1
+Version: 0.3.1
 Summary: Utility for synchronize multiple instances of VLC. Supports seek, play and pause. 
 Home-page: https://github.com/mrkeuz/vlcsync/
 License: MIT
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 VLC Sync
 ========
 
-Utility for synchronize multiple instances of VLC. Supports seek, play and pause. 
+Utility for synchronize multiple instances of VLC. Supports seek, play and pause/stop, playlist and volume sync. 
   
 
 #### Motivation
@@ -71,6 +71,10 @@ $ vlcsync --rc-host 192.168.1.100:12345 --rc-host 192.168.1.50:54321
 # For disable local discovery (only remote instances)
 $ vlcsync --no-local-discovery --rc-host 192.168.1.100:12345
 
+# Started from version 0.3.0 (playlists sync)
+# Support volume sync for exotic cases
+$ vlcsync --volume-sync
+
 # For help and see all options
 $ vlcsync --help
 ```
@@ -89,7 +93,7 @@ Awesome [use-case](./docs/awesome.md) ideas
   Difference between videos can be **up to ~0.5 seconds** in worst case. Especially when playing from network share, 
   due buffering time and network latency.
 
-- Currently, tested only on:
+- Currently, tested on:
   - Linux (Ubuntu 20.04)
   - Windows 7 (32-bit)
   - Windows 10 (64-bit)
@@ -102,7 +106,7 @@ Awesome [use-case](./docs/awesome.md) ideas
 - [Syncplay](https://github.com/Syncplay/syncplay) - very promised, but little [complicated](https://github.com/Syncplay/syncplay/discussions/463) for sync different videos
 - [bino](https://bino3d.org/) - working, very strange controls, file dialog not working and only fullscreen
 - [gridplayer](https://github.com/vzhd1701/gridplayer) - low fps by some reason
-- [mpv](https://github.com/mpv-player/mpv) - with [mixing multiple videos](https://superuser.com/a/1325668/1272472) in one window. Unfortunally does not support multiple screens
+- [mpv](https://github.com/mpv-player/mpv) - with [mixing multiple videos](https://superuser.com/a/1325668/1272472) in one window. Unfortunately does not support multiple screens
 - [AVPlayer](http://www.awesomevideoplayer.com/) - only Win, macOS, up to 4 videos in free version
 
 ## Contributing

vlcsync-0.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+vlcsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vlcsync/cli.py,sha256=ssoMtW_DorOs0QK5-mEqm6itQQQVci86B8OA2Ed4Nw0,2005
+vlcsync/cli_utils.py,sha256=hXSljymGPU5AzFr706Ea-81wxkVCYLhZY-ug-JExZ0E,883
+vlcsync/main.py,sha256=An0NQ4jy3mfygwxko_UA3Sdwri9yidcUTTCP3SoyrpI,303
+vlcsync/syncer.py,sha256=x9w0LWmCUtFlMFTi01q8BBos0d9fwUpOQMo0dko6n_0,3854
+vlcsync/vlc.py,sha256=dBrg2TYQswhewtUveBilp0jadfMQAMRZkqgBukUK3F0,8528
+vlcsync/vlc_finder.py,sha256=7BXhOeJG8lRqYJ7dbrLU3Ps8ghUPh666YkAZjNom-cw,2770
+vlcsync/vlc_socket.py,sha256=WQAtNoitc49sst0oRG0bEuTkgw6a2TJXVE9iSWQaMa0,1850
+vlcsync/vlc_state.py,sha256=8RpmxVS_zijqYw9rxpmnN5QwM3Sk1FmqgTxgCH3U8kU,3133
+vlcsync-0.3.1.dist-info/entry_points.txt,sha256=2m_39oATnFzf5kuvlhkayyWSmW0tUefyNk9dVP4A7B0,45
+vlcsync-0.3.1.dist-info/LICENSE.md,sha256=Q6ik40IpumjnuWfS1c69jnEyxAPTBV2v04DesGSgLPM,1074
+vlcsync-0.3.1.dist-info/WHEEL,sha256=DA86_h4QwwzGeRoz62o1svYt5kGEXpoUTuTtwzoTb30,83
+vlcsync-0.3.1.dist-info/METADATA,sha256=UWdLvYjpLAGk9KC_0pGnDrpF9dEdwZM6qs9cmrj-qrs,4258
+vlcsync-0.3.1.dist-info/RECORD,,

vlcsync-0.2.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-vlcsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vlcsync/cli.py,sha256=y-NXVFVEc92PYSz6S1qZRn8t_RYtH8SK7FxEd6bAsuU,1382
-vlcsync/cli_utils.py,sha256=hXSljymGPU5AzFr706Ea-81wxkVCYLhZY-ug-JExZ0E,883
-vlcsync/main.py,sha256=An0NQ4jy3mfygwxko_UA3Sdwri9yidcUTTCP3SoyrpI,303
-vlcsync/syncer.py,sha256=_x5Lm3iOALgqukEyXi1R8-CJrGHp6vGFm8pKRX8YKwU,2503
-vlcsync/vlc.py,sha256=InpH8u9f2dG6jw-LerrJSygMvboyk84hksO7-QBh5Iw,5856
-vlcsync/vlc_finder.py,sha256=8cc1IktUqmaY8xjWjgO6uVkpvtb7tAwPOlPBck1-oZY,2727
-vlcsync/vlc_socket.py,sha256=WQAtNoitc49sst0oRG0bEuTkgw6a2TJXVE9iSWQaMa0,1850
-vlcsync/vlc_state.py,sha256=Y2jtVO9vHIJCqOdPzBAM9TC3e4R_wxhgYQsYwOgbi7U,2442
-vlcsync-0.2.1.dist-info/entry_points.txt,sha256=2m_39oATnFzf5kuvlhkayyWSmW0tUefyNk9dVP4A7B0,45
-vlcsync-0.2.1.dist-info/LICENSE.md,sha256=Q6ik40IpumjnuWfS1c69jnEyxAPTBV2v04DesGSgLPM,1074
-vlcsync-0.2.1.dist-info/WHEEL,sha256=DA86_h4QwwzGeRoz62o1svYt5kGEXpoUTuTtwzoTb30,83
-vlcsync-0.2.1.dist-info/METADATA,sha256=TCCRF2Fynjgiolg_sNFi9ItcFX3fN0ca7omY5Dgw-X4,4121
-vlcsync-0.2.1.dist-info/RECORD,,