Python instead of jq

import pprint
dd = defaultdict(set)
q = [dd[rec[:2]].add(rec[2])
     for db in [[(ph, pp, name), (rh, rp, name)]
                for i, d in enumerate(databases)
                for name in [d.get('name', f'Unnamed{i}')]
                for prim in [d.get('primary', {})]
                for ph in [prim.get('host')]
                for pp in [prim.get('port')]
                for repl in d.get('replicas', [{}])  # <-- ATTENTION: [{}] else nested "for"-s stop!
                for rh in [repl.get('host')]
                for rp in [repl.get('port')]]
     for rec in db if rec[0] and rec[1]]
conflicts = {k:v for k,v in dd.items() if len(v) > 1}
print(f'DATABASES HAVING PORT CONFLICTS (WAY 2): {conflicts}')

for db in databases:
    t1 = ...      # create once!
    ...
    for repl in db['replicas']:
        t2 = ...  # and this one!
        ...

q = [d.get('name', 'Unnamed') for d in databases if d.get('replicas', []) == []]
print(f'DATABASE NAMES WITHOUT REPLICAS: {q}')

q = sum(len(rs) for d in databases for rs in [d.get('replicas', [])]) / len(databases)
print(f'AVERAGE NUMBER OF REPLICAS PER DATABASE: {q}')

import pprint

dat2 = {
  'query': {
    'pages': [
      {
        '21721040': {
          'pageid': 21721040,
          'ns': 0,
          'title': 'Stack Overflow',
          'extract': 'Some interesting text about Stack Overflow'
        }
      },
      {
        '21721041': {
          'pageid': 21721041,
          'ns': 0,
          'title': 'Baeldung',
          'extract': 'A great place to learn about Java'
        }
      },
      {
        '11111111': {
          'pageid': 11111111,
          'ns': 0,
          'title': 'FAKE'
        }
      }      
    ]
  }
}
q = [{'page_title':t, 'page_description': p.get('extract', '<no description>')}
     for pages_dict in dat2.get('query',{}).get('pages',[])
     if (p := next(iter(pages_dict.values()), {}))  # take the 1st value (we see only one always)
     if (t := p.get('title'))]
pprint.pprint(q, sort_dicts=False)

def query(team_name):
    return [kid
            for t in cdat.get('teams',[])
            if (tid := t.get('id'))
            if (tn := t.get('name')) and tn == team_name
            for u in cdat.get('users',[])
            if (uid := u.get('id'))
            if (uti := u.get('team_id')) and uti == tid
            for k in cdat.get('tasks',[])
            if (kid := k.get('id'))
            if (aid := k.get('assignee_id')) and aid == uid]
print('TASKS OF BACKEND TEAM:', query('Backend'))
print('TASKS OF FRONTEND TEAM:', query('Frontend'))

import pprint
q = ({'DANGLED PROJECT_ID IN TASKS':
      {kpid for k in cdat.get('tasks',[])
       if (kpid := k.get('project_id'))}
      -
      {p.get('id') for p in cdat.get('projects',[])}}
     |
     {'DANGLED ASSIGNEE_ID IN TASKS':
      {aid for k in cdat.get('tasks',[])
       if (aid := k.get('assignee_id'))}
      -
      {u.get('id') for u in cdat.get('users',[])}}
     |
     {'DANGLED DEPENDS_ON IN TASKS':
      {kdon for k in cdat.get('tasks',[])
       for kdon in k.get('depends_on',[])}
      -
      {k.get('id') for k in cdat.get('tasks',[])}}
     |
     {'DANGLED PARENT_ID IN BRANCHES':
      {bpid for b in cdat.get('branches',[])
       if (bpid := b.get('parent_id'))}
      -
      {b.get('id') for b in cdat.get('branches',[])}}
     |
     {'DANGLED BRANCH_IDS IN REPOSITORIES':
      {rbid for r in cdat.get('repositories',[])
       for rbid in r.get('branch_ids',[])}
      -
      {b.get('id') for b in cdat.get('branches',[])}}
     |
     {'DANGLED REPOSITORY_ID IN PROJECTS':
      {prid for p in cdat.get('projects',[])
       if (prid := p.get('repository_id'))}
      -
      {r.get('id') for r in cdat.get('repositories',[])}}
     |
     {'DANGLED PROJECT_IDS IN TEAMS':
      {tpid for t in cdat.get('teams',[])
       for tpid in t.get('project_ids',[])}
      -
      {p.get('id') for p in cdat.get('projects',[])}}
     |
     {'DANGLED LEAD_ID IN TEAMS':
      {tlid for t in cdat.get('teams',[])
       if (tlid := t.get('lead_id'))}
      -
      {u.get('id') for u in cdat.get('users',[])}}
     |
     {'DANGLED TASK_IDS IN USERS':
      {utid for u in cdat.get('users',[])
       for utid in u.get('task_ids',[])}
      -
      {k.get('id') for k in cdat.get('tasks',[])}
     }
     |
     {'DANGLED TEAM_ID IN USERS':
      {utid for u in cdat.get('users',[])
       if (utid := u.get('team_id'))}
      -
      {t.get('id') for t in cdat.get('teams',[])}}
    )
pprint.pprint(q, sort_dicts=False)

q = ({k.get('id') for k in cdat.get('tasks',[])}
     -
     {kdon for k in cdat.get('tasks',[])
     for kdon in k.get('depends_on',[])})
print(f'TASKS THAT NO ONE DEPENDS ON: {q}')

from functools import *
from itertools import *

q = {pname for s in starmap(
    set.intersection,
    permutations((set(m.get('project_ids',[])) for m in cdat.get('teams',[])),
                 2))
     for e in s
     for p in cdat.get('projects',[])
     if (pname := p.get('name')) and p.get('id') == e}
print(q)

from collections import Counter

cnt = Counter(pid for t in cdat.get('teams',[])
              for pid in t.get('project_ids',[]))
q = {pname for p in cdat.get('projects',[])
     if cnt[p['id']] > 1 and (pname := p.get('name'))}
print(q)

q1 = [(t.get('id'),d)
     for t in cdat.get('tasks',[])
     for d in t.get('depends_on',[])]
q2 = [('K1', 'K2'),
      ('K1', 'K3'),
      ('K2', 'K4'),
      ('K3', 'K1')]
q3 = [('K1', 'K3'),
      ('K1', 'K2'),
      ('K2', 'K1'),
      ('K3', 'K4')]
q4 = [('K1','K4'),
      ('K1','K2'),
      ('K2','K5'),
      ('K2','K3'),
      ('K3','K6'),
      ('K3','K1')]
def cycle1(q, d=None, passed=None):
    return (next((l for d in q
                  if (l := cycle1(q, d, []))), None)
            if d is None
            else (passed
                  if d[1] in (p[0] for p in passed)
                  else next((r for n in filter(lambda x:d[1]==x[0], q)
                             if (r := cycle1(q, n, passed + [d,n]))), None)))
for q in (q1, q2, q3, q4):
    print('Q:', q, '\n   CYCLES:', cycle1(q))

def cycle2(q, d=None, passed=None):
    if d is None:
        for d in q:
            if l := cycle2(q, d, []):
                return l
    else:
        fr,to = d
        if to in (p[0] for p in passed):
            return passed
        else:
            for n in filter(lambda d:to==d[0], q):
                if r := cycle2(q, n, passed + ([n] if passed and passed[-1]==d else [d,n])):
                    return r
for q in (q1, q2, q3, q4):
    print('Q:', q, '\n   CYCLES:', ',  '.join(map(' -> '.join, rs) if (rs:=cycle2(q)) else ['<none>']))

...
        for d in q:
            if l := cycle2(q, d, []):
                return l

q1 = [(t.get('id'),d)
     for t in cdat.get('tasks',[])
     for d in t.get('depends_on',[])]
q2 = [('K1', 'K2'),
      ('K1', 'K3'),
      ('K2', 'K4'),
      ('K3', 'K1')]
q3 = [('K1', 'K3'),
      ('K1', 'K2'),
      ('K2', 'K1'),
      ('K3', 'K4')]
q4 = [('K1','K4'),
      ('K1','K2'),
      ('K2','K5'),
      ('K2','K3'),
      ('K3','K6'),
      ('K3','K1')]

def depth(q, root=None, dest=None, nodes=None):
    if root is None:
        nodes = defaultdict(set)
        for root, dest in q:
            depth(q, root, dest, nodes)
        return dict(nodes)
    else:
        if root != dest:
            nodes[root].add(dest)
        for successor in {n[1] for n in q if n[0]==dest}:
            if successor not in nodes[root]:
                depth(q, root, successor, nodes)
    
for q in (q1, q2, q3, q4):
    print('Q:', q, '\nTASK DEPS:', depth(q))

from collections import defaultdict

p1 = [('K1', 'K2'),
      ('K3', 'K4')]
p2 = [('K1', 'K2'),
      ('K1', 'K3'),
      ('K2', 'K4'),
      ('K3', 'K1')]
p3 = [('K1', 'K3'),
      ('K1', 'K2'),
      ('K2', 'K1'),
      ('K3', 'K4')]
p4 = [('K1', 'K4'),
      ('K1', 'K2'),
      ('K2', 'K5'),
      ('K2', 'K3'),
      ('K3', 'K6'),
      ('K3', 'K1')]
p5 = [('A', 'B'),
      ('A', 'C'),
      ('B', 'D'),
      ('C', 'D'),
      ('D', 'E')]
p6 = [('A', 'B'),
      ('B', 'C'),
      ('D', 'E')]

def iter_depth(q):
    if not q:
        return []
    deps = defaultdict(set)
    # `route` is a stack for kind of "backtracking" (return from DFS, Depth-First-Search):
    route = []
    look_for = q[0][0]
    # `q2` is the `q` value to be restored after return from look for `dst` (DFS);
    # the stack `route` is used as such stack: a tuple with the current `look_for` and an integer -
    # the position in `q`, - before to dive to look for `dst`:
    q2 = q
    # the current position in `q` (needed for restoring after return from DFS)
    i = 0
    while 1:
        for pair in q2:
            src, dst = pair
            if (src == look_for and
                (not route or dst not in deps[route[0][0]])):
                # found desired src but with avoid of loops - `... and (not route ...)`, ie,
                # we did not hit the initial `look_for`:
                route.append((look_for, i+1))
                deps[look_for].add(dst)
                # Here we can add `dst` which is = initial `look_for`. It is not bad, bcs
                # it allows to see loop later. Otherwise, use `if dst != route[0][0]: ...`
                deps[route[0][0]].add(dst)
                look_for = dst
                break
            i += 1
        else:  # "if" in "for" was not hit, "for" completed
            if route:
                look_for, i = route.pop()
                q2 = q[i:]  # kind of backtracking
            else:
                if q2 and (q2 := [p for p in q2 if p[0] not in deps]):  # or `...in q`
                    # `q2` now - independent pairs, not children of the initial `look_for`,
                    # if there are any yet - continue DFS with another, independent `look_for`:
                    look_for = q2[0][0]
                    continue
                else:
                    # all pair heads in `q2` is already in `deps`, nothing more to search:
                    break
    return dict(deps)
for q in (p1, p2, p3, p4, p5, p6):
    print('Q:', q, '\n   TASK DEPS:', iter_depth(q))

from networkx import *

p1 = [('K1', 'K2'),
      ('K3', 'K4')]
p2 = [('K1', 'K2'),
      ('K1', 'K3'),
      ('K2', 'K4'),
      ('K3', 'K1')]
p3 = [('K1', 'K3'),
      ('K1', 'K2'),
      ('K2', 'K1'),
      ('K3', 'K4')]
p4 = [('K1', 'K4'),
      ('K1', 'K2'),
      ('K2', 'K5'),
      ('K2', 'K3'),
      ('K3', 'K6'),
      ('K3', 'K1')]
p5 = [('A', 'B'),
      ('A', 'C'),
      ('B', 'D'),
      ('C', 'D'),
      ('D', 'E')]
p6 = [('A', 'B'),
      ('B', 'C'),
      ('D', 'E')]

for q in (p1,p2,p3,p4,p5,p6):
    dg = DiGraph()
    dg.add_edges_from(q)
    deps = {n:ds  for n in dg.nodes
            if (ds := descendants(dg, n))}
    print('Q:', q, '\n   TASK DEPS:', deps)

def query(user_name):
    q = {(r.get('id'), r.get('url', '<no url>'))
         for u in cdat.get('users',[])
         if ((u.get('name') == user_name) and
             (utid := u.get('team_id')))
         for t in cdat.get('teams',[])
         if t.get('id') == utid and u.get('id') == t.get('lead_id')
         if (tpids := t.get('project_ids',[]))
         for p in cdat.get('projects',[])
         if (p.get('id') in tpids and (prid := p.get('repository_id')))
         for r in cdat.get('repositories',[])
         if r.get('id') == prid}
    return q
print('REPOSITORIES USED BY TEAM LED BY ALICE:\n  ', query('Alice'))
print('REPOSITORIES USED BY TEAM LED BY CAROL:\n  ', query('Carol'))
print('REPOSITORIES USED BY TEAM LED BY BOB:\n  ', query('Bob'))

c = Counter(uti for k in cdat.get('tasks',[])
            if (kaid := k.get('assignee_id'))
            for u in cdat.get('users',[])
            if (u.get('id') == kaid and
                (uti := u.get('team_id'))))
q = {tn:c[t.get('id')] for t in cdat.get('teams',[])
     if (tn := t.get('name'))}
pprint.pprint(q)

q = [(t.get('id'), d)
     for t in cdat.get('tasks',[])
     for d in t.get('depends_on',[])]
q1 = iter_depth(q)
q2 = defaultdict(int)
for u,c in ((u.get('name'), 1 + len(q1.get(t.get('id'),[]))) # look at `1 + ...`
            for u in cdat.get('users',[])
            for t in cdat.get('tasks',[])
            if u.get('id') == t.get('assignee_id')):
    q2[u] += c
print('TASKS WITH DIRECT DEPS:', q)
print('TASKS WITH DEPS IN DEPTH:', q1)
print('USERS AND TASKS NUMBER:', q2)
print('USER WITH THE MOST TASKS:', max(q2, key=q2.get))

from collections import defaultdict
inv = defaultdict(set)
for t in cdat.get('tasks',[]):
    if tpid := t.get('project_id'):
        inv[tpid].add(t.get('id'))
print('PROJECT -> TASKS:', dict(inv))

inv = [(tpid, t.get('id'))
       for t in cdat.get('tasks',[])
       if (tpid := t.get('project_id'))]
print('PROJECT -> TASKS:', inv)