File: pretty_diff_checker.py

package info (click to toggle)
raysession 0.17.2-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 19,168 kB
  • sloc: python: 44,371; sh: 1,538; makefile: 208; xml: 86
file content (163 lines) | stat: -rw-r--r-- 6,146 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

from typing import TYPE_CHECKING
from patshared import PrettyDiff

if TYPE_CHECKING:
    from patchbay_manager import PatchbayManager
# from port_data import PortDataList


class PrettyDiffChecker:
    def __init__(self, manager: 'PatchbayManager'):
        self.mng = manager
        self.metadatas = self.mng.jack_metadatas
        self.pretty_names = self.mng.custom_names
        self.client_name_uuids = self.mng.client_uuids
        
        self.clients_diff = dict[int, PrettyDiff]()
        self.ports_diff = dict[int, PrettyDiff]()
        self.pretty_diff = PrettyDiff.NO_DIFF
        self.full_update()
    
    def uuid_change(self, uuid: int):
        change_diff_old = PrettyDiff.NO_DIFF
        change_diff_new = PrettyDiff.NO_DIFF
        glob_diff_old = self.pretty_diff
        glob_diff_new = PrettyDiff.NO_DIFF

        if uuid in self.clients_diff:
            change_diff_old = self.clients_diff[uuid]

            for client_name, client_uuid in self.client_name_uuids.items():
                if client_uuid != uuid:
                    continue

                self.clients_diff[uuid] = self._get_diff(
                    self.pretty_names.custom_group(client_name),
                    self.metadatas.pretty_name(uuid))
                change_diff_new = self.clients_diff[uuid]
                break
        
        elif uuid in self.ports_diff:
            change_diff_old = self.ports_diff[uuid]
            port = self.mng.get_port_from_uuid(uuid)

            if port is not None:
                self.ports_diff[uuid] = self._get_diff(
                    self.pretty_names.custom_port(port.full_name),
                    self.metadatas.pretty_name(uuid))
                change_diff_new = self.ports_diff[uuid]
        
        else:
            port = self.mng.get_port_from_uuid(uuid)
            if port is None:
                for client_name, client_uuid \
                        in self.client_name_uuids.items():
                    if client_uuid != uuid:
                        continue
                    
                    self.clients_diff[uuid] = self._get_diff(
                        self.pretty_names.custom_group(client_name),
                        self.metadatas.pretty_name(uuid))
                    change_diff_new = self.clients_diff[uuid]
                    break
            else:
                self.ports_diff[uuid] = self._get_diff(
                    self.pretty_names.custom_port(port.full_name),
                    self.metadatas.pretty_name(uuid))
                change_diff_new = self.ports_diff[uuid]
        
        # In many cases, no need to reevaluate all pretty names change states
        # to know the diff state
        match glob_diff_old:
            case PrettyDiff.NO_DIFF:
                glob_diff_new = change_diff_new
            case PrettyDiff.NON_BOTH:
                if change_diff_old is PrettyDiff.NO_DIFF:
                    glob_diff_new = PrettyDiff.NON_BOTH
                else:
                    glob_diff_new = self.get_glob_diff()
            case _:
                if glob_diff_old in change_diff_old:
                    glob_diff_new = self.get_glob_diff()
                else:
                    glob_diff_new = glob_diff_old | change_diff_new
        
        if glob_diff_new is not glob_diff_old:
            if self.mng.options_dialog is not None:
                self.mng.options_dialog.change_pretty_diff(glob_diff_new)

        self.pretty_diff = glob_diff_new
    
    def client_pretty_name_changed(self, client_name: str):
        client_uuid = self.client_name_uuids.get(client_name)
        if client_uuid is None:
            return

        self.uuid_change(client_uuid)
        
    def port_pretty_name_changed(self, port_name: str):
        port = self.mng.get_port_from_name(port_name)
        if port is None or not port.type.is_jack:
            return
        
        self.uuid_change(port.uuid)
    
    def _get_diff(self, pretty_name: str, jack_pretty_name: str):
        if pretty_name == jack_pretty_name:
            return PrettyDiff.NO_DIFF
        
        if pretty_name and jack_pretty_name:
            return PrettyDiff.NON_BOTH
        
        if pretty_name:
            return PrettyDiff.NON_EXPORTED
        return PrettyDiff.NON_IMPORTED
    
    def full_update(self):
        self.clients_diff.clear()
        self.ports_diff.clear()

        for client_name, client_uuid in self.client_name_uuids.items():
            self.clients_diff[client_uuid] = self._get_diff(
                self.pretty_names.custom_group(client_name),
                self.metadatas.pretty_name(client_uuid))
        
        for group in self.mng.groups:
            for port in group.ports:
                if not port.type.is_jack:
                    continue
                
                self.ports_diff[port.uuid] = self._get_diff(
                    self.pretty_names.custom_port(port.full_name),
                    self.metadatas.pretty_name(port.uuid))
        
        self.pretty_diff = self.get_glob_diff()
        if self.mng.options_dialog:
            self.mng.options_dialog.change_pretty_diff(self.pretty_diff)

    def print_diffs(self):
        out_dict = {'client_diffs': dict[int, PrettyDiff](),
                    'port_diffs  ': dict[int, PrettyDiff]()}
        for uuid, diff in self.clients_diff.items():
            if diff is not PrettyDiff.NO_DIFF:
                out_dict['client_diffs'][uuid] = diff
        
        for uuid, diff in self.ports_diff.items():
            if diff is not PrettyDiff.NO_DIFF:
                out_dict['port_diffs  '][uuid] = diff
        
        return out_dict

    def get_glob_diff(self) -> PrettyDiff:
        glob_diff = PrettyDiff.NO_DIFF
        for pretty_diff in self.clients_diff.values():
            glob_diff |= pretty_diff
            if glob_diff is PrettyDiff.NON_BOTH:
                return glob_diff
            
        for pretty_diff in self.ports_diff.values():
            glob_diff |= pretty_diff
            if glob_diff is PrettyDiff.NON_BOTH:
                return glob_diff
        return glob_diff