Skip to content

Index

Dashboard specific util function

export_layout(gridstate) #

Exports current grid layout to JSON dict.

Source code in src/sdss_explorer/dashboard/util/io.py 
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
def export_layout(gridstate: GridData) -> dict[str, Any]:
    """Exports current grid layout to JSON dict."""
    # fetch layout and states
    layouts = deepcopy(gridstate.grid_layout.value)
    plotstates = gridstate.states.value

    # pop and convert plot state to dict.
    for layout in layouts:
        layout.pop("i")
    states = list()
    for state in plotstates:
        newstate = dict()
        for k, v in vars(state).items():
            if k == "Lookup":
                continue

            elif k in {"plottype", "xmapping", "ymapping", "colormapping"}:
                newstate[k] = v
            elif k == "subset":
                newstate[k] = v.value
            else:
                newstate[k] = v.value
        states.append(newstate)

    return {"layout": layouts, "states": states}

export_subset(subset) #

Exports a given subset to JSON dict.

Parameters:

Name Type Description Default
subset Subset

a given subset

 required

Returns:

Name Type Description
data dict[str, str | list[str]]

a compiled dictionary
Source code in src/sdss_explorer/dashboard/util/io.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def export_subset(subset: Subset) -> dict[str, str | list[str]]:
    """Exports a given subset to JSON dict.

    Args:
        subset: a given subset

    Returns:
        data: a compiled dictionary

    """
    # NOTE: manually typed, otherwise using asdict will dump entire df into memory
    data = dict(
        name=subset.name,
        expression=subset.expression,
        dataset=subset.dataset,
        carton=subset.carton,
        mapper=subset.mapper,
        flags=subset.flags,
    )
    return data

export_vcdata(vcdata) #

Export the active Virtual Columns to a JSON dict.

Source code in src/sdss_explorer/dashboard/util/io.py 
74
75
76
def export_vcdata(vcdata: VCList) -> dict[str, str]:
    """Export the active Virtual Columns to a JSON dict."""
    return dict(vcdata.columns.value)

filter_regex(data, query, col=None) #

Filter a dataframe or list by a column for a given query

Source code in src/sdss_explorer/dashboard/util/regex.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def filter_regex(data: vx.DataFrame | pd.DataFrame | List,
                 query: str,
                 col: Optional[str] = None):
    """Filter a dataframe or list by a column for a given query"""
    try:
        if len(query) == 0:
            return []
        else:
            if isinstance(data, vx.DataFrame) or isinstance(
                    data, pd.DataFrame):
                return data[col].str.contains(gen_fuzzy_regex(query),
                                              regex=True)
            # regex a list
            elif isinstance(data, list):
                return list(
                    filter(re.compile(gen_fuzzy_regex(query)).search, data))
    except Exception:
        Alert.update(
            message=
            "Filter on autocomplete crashed! If persistent, please inform server admins.",
            color="error",
        )
        return []

gen_fuzzy_regex(input_string) #

Generate a basic fuzzy finding regex pattern from a string.

A string could be "a foo bar" and the pattern would become: ((a).(foo).(bar))|((a).(bar).(foo))|((foo).(a).(bar))|...

:param input_string: the input string to generate the pattern from :return: the generated pattern as a string

Source code in src/sdss_explorer/dashboard/util/regex.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def gen_fuzzy_regex(input_string: str) -> str:
    """Generate a basic fuzzy finding regex pattern from a string.

    A string could be "a foo bar" and the pattern would become:
    ((a).*(foo).*(bar))|((a).*(bar).*(foo))|((foo).*(a).*(bar))|...

    :param input_string: the input string to generate the pattern from
    :return: the generated pattern as a string
    """
    # escape special characters and filter the words for 0 length
    words = [re.escape(word) for word in input_string.split() if word]
    words.sort(key=len)  # sort for short matches first

    # search all permuatations
    word_permutations = permutations(words)
    patterns = []
    for perm in word_permutations:
        pattern_part = ".*".join(f"(?i)({word})" for word in perm)
        patterns.append(f"({pattern_part})")

    return "|".join(patterns)