setta 0.0.1.dev0__py3-none-any.whl → 0.0.2__py3-none-any.whl

setta/utils/generate_memorable_string.py

@@ -0,0 +1,431 @@
+import random
+
+
+def generate_memorable_available_string(taken_strings):
+    name = None
+    while (not name) or name in taken_strings:
+        name = generate_memorable_string()
+    return name
+
+
+def generate_memorable_string(num_words=2, separator="_"):
+    """
+    Generate a random name by combining words from predefined lists.
+
+    Args:
+        num_words (int): Number of words to combine (default: 2)
+        separator (str): String to join words with (default: '_')
+
+    Returns:
+        str: Combined random words
+    """
+
+    adjectives = [
+        "happy",
+        "clever",
+        "swift",
+        "brave",
+        "bright",
+        "calm",
+        "eager",
+        "fierce",
+        "gentle",
+        "kind",
+        "lively",
+        "proud",
+        "quiet",
+        "rapid",
+        "sharp",
+        "smart",
+        "strong",
+        "warm",
+        "wise",
+        "bold",
+        "crisp",
+        "deep",
+        "free",
+        "grand",
+        "high",
+        "keen",
+        "neat",
+        "rich",
+        "safe",
+        "true",
+        "young",
+        "dark",
+        "light",
+        "wild",
+        "soft",
+        "loud",
+        "quick",
+        "slow",
+        "tall",
+        "short",
+        "fresh",
+        "clean",
+        "cool",
+        "hot",
+        "fair",
+        "sweet",
+        "tough",
+        "pure",
+        "nice",
+        "raw",
+        "real",
+        "rare",
+        "fine",
+        "vast",
+        "mild",
+        "firm",
+        "fast",
+        "late",
+        "main",
+        "wide",
+        "deep",
+        "blue",
+        "red",
+        "green",
+        "gold",
+        "pink",
+        "gray",
+        "tiny",
+        "huge",
+        "broad",
+        "flat",
+        "thick",
+        "thin",
+        "white",
+        "black",
+        "round",
+        "dry",
+        "wet",
+        "full",
+        "empty",
+        "heavy",
+        "light",
+        "loose",
+        "tight",
+        "long",
+        "brief",
+        "clear",
+        "dark",
+        "busy",
+        "lazy",
+        "spare",
+        "prime",
+        "royal",
+        "plain",
+        "spare",
+        "crude",
+        "chief",
+        "swift",
+        "dim",
+        "dull",
+        "rough",
+        "smooth",
+        "still",
+        "small",
+        "great",
+        "quick",
+        "ready",
+        "right",
+        "rust",
+        "tame",
+        "vital",
+        "young",
+        "zinc",
+        "zesty",
+    ]
+
+    nouns = [
+        "apple",
+        "bear",
+        "bird",
+        "cat",
+        "cloud",
+        "deer",
+        "dog",
+        "fish",
+        "fox",
+        "frog",
+        "hawk",
+        "lion",
+        "moon",
+        "owl",
+        "pine",
+        "rose",
+        "star",
+        "sun",
+        "tree",
+        "wolf",
+        "river",
+        "mountain",
+        "ocean",
+        "forest",
+        "desert",
+        "valley",
+        "meadow",
+        "garden",
+        "brook",
+        "lake",
+        "beach",
+        "cliff",
+        "coast",
+        "creek",
+        "field",
+        "flame",
+        "flood",
+        "frost",
+        "glade",
+        "grove",
+        "shore",
+        "spring",
+        "storm",
+        "stream",
+        "tide",
+        "trail",
+        "whale",
+        "wind",
+        "wood",
+        "world",
+        "amber",
+        "ash",
+        "balm",
+        "bark",
+        "bay",
+        "blade",
+        "bloom",
+        "branch",
+        "brass",
+        "bronze",
+        "cane",
+        "cedar",
+        "chalk",
+        "clay",
+        "cliff",
+        "coal",
+        "coast",
+        "coral",
+        "crown",
+        "crystal",
+        "dew",
+        "dove",
+        "drake",
+        "dune",
+        "dust",
+        "elm",
+        "fern",
+        "flake",
+        "flame",
+        "flock",
+        "foam",
+        "fog",
+        "frost",
+        "gale",
+        "gem",
+        "gill",
+        "glacier",
+        "grove",
+        "gull",
+        "harbor",
+        "hare",
+        "heath",
+        "hill",
+        "jazz",
+        "jewel",
+        "kale",
+        "kelp",
+        "kite",
+        "lark",
+        "leaf",
+        "lime",
+        "mane",
+        "marsh",
+        "mint",
+        "mist",
+        "moss",
+        "nest",
+        "night",
+        "north",
+        "oak",
+        "opal",
+        "otter",
+        "palm",
+        "peak",
+        "pear",
+        "pearl",
+        "petal",
+        "pike",
+        "pine",
+        "plant",
+        "plum",
+        "pond",
+        "pool",
+        "quail",
+        "queen",
+        "quill",
+        "rain",
+        "reef",
+        "rice",
+        "ridge",
+        "rock",
+        "root",
+        "rose",
+        "ruby",
+        "rush",
+        "sage",
+        "sail",
+        "salt",
+        "sand",
+        "seal",
+        "seed",
+        "shark",
+        "shell",
+        "shore",
+        "silk",
+        "slag",
+        "slate",
+        "sleet",
+        "slope",
+        "snow",
+        "south",
+        "spark",
+        "spine",
+        "spray",
+        "spring",
+        "sprout",
+        "squid",
+        "star",
+        "stone",
+        "storm",
+        "swan",
+        "swift",
+        "tank",
+        "tide",
+        "tiger",
+        "torch",
+        "trout",
+        "tulip",
+        "vapor",
+        "vine",
+        "voice",
+        "wave",
+        "weed",
+        "well",
+        "whale",
+        "wind",
+        "wing",
+        "winter",
+        "wolf",
+        "womb",
+        "wood",
+        "wren",
+        "yarn",
+        "yeast",
+        "zebra",
+    ]
+
+    verbs = [
+        "running",
+        "jumping",
+        "flying",
+        "dancing",
+        "singing",
+        "laughing",
+        "sleeping",
+        "dreaming",
+        "playing",
+        "swimming",
+        "climbing",
+        "diving",
+        "gliding",
+        "hopping",
+        "leaping",
+        "racing",
+        "skating",
+        "sliding",
+        "walking",
+        "wandering",
+        "acting",
+        "baking",
+        "being",
+        "brewing",
+        "buying",
+        "calling",
+        "caring",
+        "catching",
+        "chasing",
+        "coding",
+        "cooking",
+        "dealing",
+        "doing",
+        "drawing",
+        "driving",
+        "eating",
+        "falling",
+        "feeling",
+        "finding",
+        "flowing",
+        "giving",
+        "glowing",
+        "going",
+        "growing",
+        "having",
+        "hearing",
+        "hiding",
+        "hitting",
+        "holding",
+        "keeping",
+        "knowing",
+        "leading",
+        "leaving",
+        "making",
+        "moving",
+        "painting",
+        "playing",
+        "reading",
+        "riding",
+        "rising",
+        "saying",
+        "seeing",
+        "selling",
+        "sending",
+        "setting",
+        "shining",
+        "showing",
+        "singing",
+        "sitting",
+        "speaking",
+        "spending",
+        "standing",
+        "staying",
+        "taking",
+        "talking",
+        "teaching",
+        "telling",
+        "thinking",
+        "turning",
+        "using",
+        "waiting",
+        "watching",
+        "winning",
+        "working",
+        "writing",
+        "zooming",
+    ]
+
+    # Create a list of all word lists to choose from
+    word_lists = [adjectives, nouns, verbs]
+
+    # Select random words from different categories
+    selected_words = []
+    while len(selected_words) < num_words:
+        # Get a random word list
+        word_list = random.choice(word_lists)
+        # Get a random word from that list
+        word = random.choice(word_list)
+        # Only add if we haven't used this word yet
+        if word not in selected_words:
+            selected_words.append(word)
+
+    return separator.join(selected_words)

setta/utils/generate_new_filename.py

@@ -0,0 +1,80 @@
+import glob
+import os
+import random
+import re
+import string
+
+from setta.utils.generate_memorable_string import generate_memorable_string
+
+
+def generate_new_filename(input_pattern: str) -> str:
+    """
+    Generate a new filename based on the input pattern, adding a random memorable suffix.
+    Supports complex glob patterns including nested directories and multiple wildcards.
+    Replaces pattern characters with random valid values:
+    - [0-9] is replaced with a random digit
+    - [a-z] is replaced with a random lowercase letter
+    - ? is replaced with a random letter
+
+    Args:
+        input_pattern: Input filename or glob pattern (e.g., "file.json", "*file*.json",
+                      "dir/*/*.json", "report_??_*.json", "data[0-9].json")
+
+    Returns:
+        New filepath (as string) with a unique memorable suffix. For glob patterns with no matches,
+        generates a sensible filename following the pattern's structure.
+    """
+    # Split into directory and filename parts
+    directory = os.path.dirname(input_pattern)
+    filename = os.path.basename(input_pattern)
+
+    # If there are matching files, use the first match as template without any cleaning
+    matching_files = glob.glob(input_pattern)
+    if matching_files:
+        template_name = sorted(matching_files, key=len)[0]
+        directory = os.path.dirname(template_name)
+        filename = os.path.basename(template_name)
+        base_path, extension = os.path.splitext(filename)
+    else:
+        # Only clean the pattern if no existing files match
+        base_path, extension = os.path.splitext(filename)
+
+        # Clean the base path of glob patterns
+        cleaned_base = base_path
+
+        # Helper function to replace each match with a random choice
+        def random_replacement(pattern, choices):
+            def replace_func(match):
+                return random.choice(choices)
+
+            return re.sub(pattern, replace_func, cleaned_base)
+
+        # Replace [0-9] with random digit
+        cleaned_base = random_replacement(r"\[\d+\-\d+\]", string.digits)
+
+        # Replace [a-z] with random lowercase letter
+        cleaned_base = random_replacement(r"\[a-z\]", string.ascii_lowercase)
+
+        # Replace ? with random letter (upper or lowercase)
+        cleaned_base = random_replacement(r"\?", string.ascii_letters)
+
+        # Remove * wildcards entirely since they represent variable length matches
+        cleaned_base = re.sub(r"\*+", "", cleaned_base)
+
+        # If we've cleaned away everything, use a default name
+        if not cleaned_base or cleaned_base.isspace():
+            cleaned_base = "file"
+
+        base_path = cleaned_base
+
+    # Keep trying new suffixes until we find a filename that doesn't exist
+    while True:
+        suffix = generate_memorable_string()
+        new_filename = f"{base_path}_{suffix}{extension}"
+
+        # Reconstruct full path if there was a directory
+        if directory:
+            new_filename = os.path.join(directory, new_filename)
+
+        if not os.path.exists(new_filename):
+            return new_filename

setta/utils/section_contents.py

@@ -0,0 +1,133 @@
+from setta.utils.constants import C
+
+# js->python conversion done by claude
+
+
+def _findAllDescendants(
+    allCodeInfo,
+    codeInfoChildren,
+    codeInfoIds,
+    outputCondition,
+    stackCondition,
+    paramPathCondition=None,  # None or a function
+    earlyReturnCondition=None,  # None or a function
+):
+    output = []
+    idStack = list(reversed([x for x in codeInfoIds if stackCondition(allCodeInfo[x])]))
+    visited = set()
+    pathMap = {} if paramPathCondition else None
+
+    if paramPathCondition:
+        for id in idStack:
+            pathMap[id] = [id] if paramPathCondition(allCodeInfo[id]) else []
+
+    while len(idStack) > 0:
+        id = idStack.pop()
+        if not id or id in visited:
+            continue
+        visited.add(id)
+        currInfo = allCodeInfo[id]
+
+        if outputCondition(currInfo):
+            output.append(currInfo["id"])
+
+        if stackCondition(currInfo):
+            children = list(reversed(codeInfoChildren[currInfo["id"]]))
+            if paramPathCondition:
+                currentPath = pathMap[id]
+                for childId in children:
+                    pathMap[childId] = (
+                        [*currentPath, childId]
+                        if paramPathCondition(allCodeInfo[childId])
+                        else [*currentPath]
+                    )
+            idStack.extend(children)
+
+        if (
+            len(output) > 0
+            and earlyReturnCondition
+            and earlyReturnCondition(allCodeInfo[output[-1]])
+        ):
+            return {"ids": output, "pathMap": pathMap, "earlyReturnTriggered": True}
+
+    return {"ids": output, "pathMap": pathMap, "earlyReturnTriggered": False}
+
+
+def findAllParameters(
+    allCodeInfo,
+    codeInfoChildren,
+    startingId,
+    additionalOutputCondition=None,
+    paramPathCondition=None,
+    earlyReturnCondition=None,
+):
+    codeInfoIds = [startingId] if startingId else codeInfoChildren.get(startingId, None)
+
+    # if startingId is None, then we're starting at the root
+    # so we don't want to avoid the parameters of callables
+    def stackCondition(c):
+        return True if startingId else c.get("rcType") == C.PARAMETER
+
+    return _findAllDescendants(
+        allCodeInfo,
+        codeInfoChildren,
+        codeInfoIds or [],
+        lambda c: c.get("rcType") == C.PARAMETER
+        and (not additionalOutputCondition or additionalOutputCondition(c)),
+        stackCondition,
+        paramPathCondition,
+        earlyReturnCondition,
+    )
+
+
+def findAllParametersAndPathMaps(**kwargs):
+    return findAllParameters(
+        **kwargs, paramPathCondition=lambda p: p.get("rcType") == C.PARAMETER
+    )
+
+
+def getParamIdsToShowInArea(
+    isPinned,
+    codeInfo,
+    codeInfoChildren,
+    parentCodeInfoId,
+):
+    result = findAllParametersAndPathMaps(
+        allCodeInfo=codeInfo,
+        codeInfoChildren=codeInfoChildren,
+        startingId=parentCodeInfoId,
+    )
+    ids = result["ids"]
+    pathMap = result["pathMap"]
+    ids.reverse()
+
+    topLevelParamIds = []
+    topLevelParamIdsSet = set()
+    requiredParamIdsToPaths = {}
+
+    for a in ids:
+        # Evaluates to true if:
+        # 1. The current param's isPinned matches the isPinned condition
+        # 2. And: either the param has no children or at least one of its children is required
+        # This logic is why it's REQUIRED for ids to be reversed (processed starting with children up to ancestors)
+        if bothTruthyOrFalsey(codeInfo[a].get("isPinned"), isPinned) and (
+            len(codeInfoChildren[a]) == 0
+            or any(child in requiredParamIdsToPaths for child in codeInfoChildren[a])
+        ):
+            for p in pathMap[a]:
+                requiredParamIdsToPaths[p] = pathMap[p]
+                if pathMap[a][0] not in topLevelParamIdsSet:
+                    topLevelParamIds.append(pathMap[a][0])
+                    topLevelParamIdsSet.add(pathMap[a][0])
+
+    # unreverse results
+    topLevelParamIds.reverse()
+
+    return {
+        "requiredParamIdsToPaths": requiredParamIdsToPaths,
+        "topLevelParamIds": topLevelParamIds,
+    }
+
+
+def bothTruthyOrFalsey(a, b):
+    return (not a) == (not b) or a == b