input: Write a Python function called `compute_connectable_server_pairs` that takes a list of tuples representing the edges of a weighted tree and an integer indicating the signal speed. The function should return an integer list where each element corresponds to the number of server pairs that can be connected through a specific server, considering the given conditions:
  
  
  from typing import List, Tuple
  
  def compute_connectable_server_pairs(edges: List[Tuple[int, int, int]], signalSpeed: int) -> List[int]:
      """
      Given a weighted unrooted tree with n nodes representing servers labeled from 0 to n - 1, and an array of tuples edges where each tuple edges[i] = [a_i, b_i, weight_i] signifies a bidirectional edge between servers a_i and b_i with the corresponding weight. Additionally, an integer signalSpeed is provided.
  
      Servers a and b are considered connectable through server c if:
      1. a < b, a != c, and b != c.
      2. The distance from c to a is divisible by signalSpeed.
      3. The distance from c to b is divisible by signalSpeed.
      4. The paths from c to a and from c to b do not share any edges.
  
      The function should return a list of integers such that each element represents the count of such connectable server pairs for each server.
  
      Examples:
      >>> edges = [[0,1,1],[1,2,5],[2,3,13],[3,4,9],[4,5,2]], signalSpeed = 1
      [0,4,6,6,4,0]
      >>> edges = [[0,6,3],[6,5,3],[0,3,1],[3,2,7],[3,1,6],[3,4,2]], signalSpeed = 3
      [2,0,0,0,0,0,2]
  
      Constraints:
      2 <= n <= 1000
      edges.length == n - 1
      edges[i].length == 3
      0 <= a_i, b_i < n
      edges[i] = [a_i, b_i, weight_i]
      1 <= weight_i <= 10^6
      1 <= signalSpeed <= 10^6
      The input ensures edges form a valid tree.
      """
  
output: def compute_connectable_server_pairs(edges: List[Tuple[int, int, int]], signalSpeed: int) -> List[int]:
      from collections import defaultdict, deque
  
      def bfs(u):
          dist = [-1] * n
          dist[u] = 0
          queue = deque([u])
          while queue:
              node = queue.popleft()
              for v, w in tree[node]:
                  if dist[v] == -1:
                      dist[v] = dist[node] + w
                      queue.append(v)
          return dist
  
      n = len(edges) + 1
      tree = defaultdict(list)
      for u, v, w in edges:
          tree[u].append((v, w))
          tree[v].append((u, w))
  
      distances = []
      for i in range(n):
          distances.append(bfs(i))
  
      result = [0] * n
      for i in range(n):
          pairs = 0
          for a in range(n):
              for b in range(a + 1, n):
                  if a != i and b != i and distances[i][a] % signalSpeed == 0 and distances[i][b] % signalSpeed == 0:
                      pairs += 1
          result[i] = pairs
          
      return result