bluer-objects 6.104.1__py3-none-any.whl → 6.464.1__py3-none-any.whl

bluer_objects/README/consts.py

@@ -0,0 +1,44 @@
+import os
+from typing import Union
+
+from bluer_objects.env import abcli_path_git
+
+github_kamangir = "https://github.com/kamangir"
+designs_repo = f"{github_kamangir}/bluer-designs"
+
+
+def designs_url(suffix: str) -> str:
+    return "{}/blob/main{}".format(
+        designs_repo,
+        f"/{suffix}" if suffix else "",
+    )
+
+
+def assets_url(
+    suffix: str = "",
+    volume: Union[str, int] = "",
+    blob: bool = False,
+) -> str:
+    return "{}/assets{}/{}/main{}".format(
+        github_kamangir,
+        str(volume),
+        "blob" if blob else "raw",
+        f"/{suffix}" if suffix else "",
+    )
+
+
+assets = assets_url(volume="")
+assets2 = assets_url(volume="2")
+
+
+def assets_path(
+    suffix: str = "",
+    volume: Union[str, int] = "",
+) -> str:
+    return os.path.join(
+        abcli_path_git,
+        "assets{}{}".format(
+            str(volume),
+            f"/{suffix}" if suffix else "",
+        ),
+    )

bluer_objects/README/functions.py

@@ -3,11 +3,24 @@ import os
 import yaml
 
 from blueness import module
-
-from bluer_objects import NAME as MY_NAME, ICON as MY_ICON
-from bluer_objects.metadata import get_from_object
+from bluer_options import env
+from bluer_options.logger import shorten_text
+from bluer_objects import NAME as MY_NAME
 from bluer_objects import file
 from bluer_objects import markdown
+from bluer_objects.metadata import get_from_object
+from bluer_objects.README.process.assets import process_assets
+from bluer_objects.README.process.details import process_details
+from bluer_objects.README.process.envs import process_envs
+from bluer_objects.README.process.help import process_help
+from bluer_objects.README.process.include import process_include
+from bluer_objects.README.process.legacy import apply_legacy
+from bluer_objects.README.process.mermaid import process_mermaid
+from bluer_objects.README.process.national_internet import process_national_internet
+from bluer_objects.README.process.objects import process_objects
+from bluer_objects.README.process.title import process_title
+from bluer_objects.README.process.variables import process_variable, variables
+from bluer_objects.README.process.signature import signature
 from bluer_objects.logger import logger
 
 MY_NAME = module.name(__file__, MY_NAME)
@@ -28,6 +41,8 @@ def build(
     help_function: Union[Callable[[List[str]], str], None] = None,
     legacy_mode: bool = True,
     assets_repo: str = "kamangir/assets",
+    download: bool = env.BLUER_AI_WEB_STATUS != "offline",
+    verbose: bool = False,
 ) -> bool:
     if path:
         if path.endswith(".md"):
@@ -41,7 +56,7 @@ def build(
         MODULE_NAME = REPO_NAME
 
     logger.info(
-        "{}.build: {}-{}: {}[{}]: {} -{}> {}".format(
+        "{}.build: {}-{}: {}[{}]: {} -{}{}> {}".format(
             MY_NAME,
             NAME,
             VERSION,
@@ -49,148 +64,58 @@ def build(
             MODULE_NAME,
             template_filename,
             "+legacy-" if legacy_mode else "",
+            "download-" if download else "",
             filename,
         )
     )
 
-    table_of_items = markdown.generate_table(items, cols=cols) if cols > 0 else items
+    if verbose:
+        logger.info(f"filename: {filename}")
+        logger.info(f"items: {items}")
 
-    signature = [
-        "",
-        " ".join(
-            [
-                f"[![pylint](https://github.com/kamangir/{REPO_NAME}/actions/workflows/pylint.yml/badge.svg)](https://github.com/kamangir/{REPO_NAME}/actions/workflows/pylint.yml)",
-                f"[![pytest](https://github.com/kamangir/{REPO_NAME}/actions/workflows/pytest.yml/badge.svg)](https://github.com/kamangir/{REPO_NAME}/actions/workflows/pytest.yml)",
-                f"[![bashtest](https://github.com/kamangir/{REPO_NAME}/actions/workflows/bashtest.yml/badge.svg)](https://github.com/kamangir/{REPO_NAME}/actions/workflows/bashtest.yml)",
-                f"[![PyPI version](https://img.shields.io/pypi/v/{MODULE_NAME}.svg)](https://pypi.org/project/{MODULE_NAME}/)",
-                f"[![PyPI - Downloads](https://img.shields.io/pypi/dd/{MODULE_NAME})](https://pypistats.org/packages/{MODULE_NAME})",
-            ]
-        ),
-        "",
-        "built by {} [`{}`]({}), based on {}[`{}-{}`]({}).".format(
-            MY_ICON,
-            "bluer README",
-            "https://github.com/kamangir/bluer-objects/tree/main/bluer_objects/README",
-            f"{ICON} " if ICON else "",
-            NAME,
-            VERSION,
-            f"https://github.com/kamangir/{REPO_NAME}",
-        ),
-    ]
+    table_of_items = markdown.generate_table(items, cols=cols) if cols > 0 else items
 
     success, template = file.load_text(template_filename)
     if not success:
         return success
 
-    def apply_legacy(line: str) -> str:
-        for before, after in {
-            "yaml:::": "metadata:::",
-            "--help--": "help:::",
-            "--include": "include:::",
-            "--table--": "items:::",
-            "--signature--": "signature:::",
-        }.items():
-            line = line.replace(before, after)
-        return line
-
     if legacy_mode:
-        logger.info("applying legacy conversions...")
-        template = [apply_legacy(line) for line in template]
+        template = apply_legacy(template)
 
     content: List[str] = []
     mermaid_started: bool = False
-    variables: Dict[str, str] = {}
     for template_line in template:
         if template_line.startswith("ignore:::"):
-            content_section = [template_line.split(":::", 1)[1].strip()]
-        else:
-            if template_line.startswith("set:::"):
-                key, value = template_line.split("set:::", 1)[1].split(" ", 1)
-                variables[key] = value
-                logger.info(f":::{key} = {value}")
-                continue
-
-            for key, value in variables.items():
-                template_line = template_line.replace(
-                    f"get:::{key}",
-                    value,
-                )
-
-            if "assets:::" in template_line:
-                template_line = " ".join(
-                    [
-                        (
-                            (
-                                "![image](https://github.com/{}/blob/main/{}?raw=true)".format(
-                                    assets_repo,
-                                    token.split(":::")[1].strip(),
-                                )
-                                if any(
-                                    token.endswith(extension)
-                                    for extension in ["png", "jpg", "jpeg", "gif"]
-                                )
-                                else "[{}](https://github.com/{}/blob/main/{})".format(
-                                    file.name_and_extension(
-                                        token.split(":::")[1].strip()
-                                    ),
-                                    assets_repo,
-                                    token.split(":::")[1].strip(),
-                                )
-                            )
-                            if token.startswith("assets:::")
-                            else token
-                        )
-                        for token in template_line.split(" ")
-                    ]
-                )
-
-            if "object:::" in template_line:
-                template_line = " ".join(
-                    [
-                        (
-                            "[{}]({}/{}.tar.gz)".format(
-                                token.split(":::")[1].strip(),
-                                "TBA",
-                                token.split(":::")[1].strip(),
-                            )
-                            if token.startswith("object:::")
-                            else token
-                        )
-                        for token in template_line.split(" ")
-                    ]
-                )
-
-            content_section: List[str] = [template_line]
-
-            if template_line.startswith("details:::"):
-                suffix = template_line.split(":::", 1)[1]
-                if suffix:
-                    content_section = [
-                        "",
-                        "<details>",
-                        f"<summary>{suffix}</summary>",
-                        "",
-                    ]
-                else:
-                    content_section = [
-                        "",
-                        "</details>",
-                        "",
-                    ]
-            elif template_line.startswith("metadata:::"):
-                object_name_and_key = template_line.split(":::", 1)[1]
-                if ":::" not in object_name_and_key:
-                    object_name_and_key += ":::"
-                object_name, key = object_name_and_key.split(":::", 1)
-
-                value = get_from_object(
-                    object_name,
-                    key,
-                    {},
-                    download=True,
-                )
-
-                content_section = (
+            content += [template_line.split(":::", 1)[1].strip()]
+            continue
+
+        template_line = process_envs(template_line)
+
+        for key, value in variables.items():
+            template_line = template_line.replace(
+                f"get:::{key}",
+                value,
+            )
+
+        if "metadata:::" in template_line:
+            object_name_and_key = template_line.split("metadata:::", 1)[1]
+            if " " in object_name_and_key:
+                object_name_and_key = object_name_and_key.split(" ", 1)[0]
+            if ":::" not in object_name_and_key:
+                object_name_and_key += ":::"
+            object_name, key = object_name_and_key.split(":::", 1)
+
+            value = get_from_object(
+                object_name,
+                key,
+                {},
+                download=download,
+            )
+
+            logger.info(shorten_text(f"metadata[{object_name_and_key}] = {value}"))
+
+            if template_line.startswith("metadata:::"):
+                content += (
                     ["```yaml"]
                     + yaml.dump(
                         value,
@@ -198,85 +123,110 @@ def build(
                     ).split("\n")
                     + ["```"]
                 )
-            elif template_line.startswith("```mermaid"):
-                mermaid_started = True
-                logger.info("🧜🏽‍♀️  detected ...")
-            elif mermaid_started and template_line.startswith("```"):
-                mermaid_started = False
-            elif mermaid_started:
-                if '"' in template_line and ":::folder" not in template_line:
-                    template_line_pieces = template_line.split('"')
-                    if len(template_line_pieces) != 3:
-                        logger.error(
-                            f"🧜🏽‍♀️  mermaid line not in expected format: {template_line}."
-                        )
-                        return False
-
-                    template_line_pieces[1] = (
-                        template_line_pieces[1]
-                        .replace("<", "&lt;")
-                        .replace(">", "&gt;")
-                        .replace(" ", "<br>")
-                        .replace("~~", " ")
-                    )
-
-                    content_section = ['"'.join(template_line_pieces)]
-            elif "items:::" in template_line:
-                content_section = table_of_items
-            elif "signature:::" in template_line:
-                content_section = signature
-            elif "include:::" in template_line:
-                include_filename_relative = template_line.split(" ")[1].strip()
-                include_filename = file.absolute(
-                    include_filename_relative,
-                    file.path(template_filename),
-                )
-
-                success, content_section = file.load_text(include_filename)
-                if not success:
-                    return success
-
-                content_section = [
-                    line for line in content_section if not line.startswith("used by:")
-                ]
-
-                include_title = (template_line.split(" ", 2) + ["", "", ""])[2]
-                if include_title:
-                    content_section = [f"## {include_title}"] + content_section[1:]
-
-                if "include:::noref" not in template_line:
-                    content_section += [
-                        "using [{}]({}).".format(
-                            file.name(include_filename),
-                            include_filename_relative,
-                        )
-                    ]
-
-                logger.info(f"{MY_NAME}.build: including {include_filename} ...")
-            elif "help:::" in template_line:
-                if help_function is not None:
-                    help_command = template_line.split("help:::")[1].strip()
-
-                    tokens = help_command.strip().split(" ")[1:]
+                continue
 
-                    help_content = help_function(tokens)
-                    if not help_content:
-                        logger.warning(f"help not found: {help_command}: {tokens}")
-                        return False
+            template_line = template_line.replace(
+                f"metadata:::{object_name}:::{key}",
+                str(value),
+            )
+
+        if template_line.startswith("set:::"):
+            process_variable(template_line)
+            continue
+
+        template_line = process_assets(template_line, assets_repo)
+
+        template_line = process_objects(template_line)
+
+        if template_line.startswith("details:::"):
+            content += process_details(template_line)
+            continue
+
+        if "items:::" in template_line:
+            content += table_of_items
+            continue
+
+        if "include:::" in template_line:
+            content += process_include(
+                template_line,
+                file.path(template_filename),
+            )
+            continue
+
+        if "signature:::" in template_line:
+            content += signature(
+                REPO_NAME,
+                NAME,
+                ICON,
+                MODULE_NAME,
+                VERSION,
+            )
+            continue
+
+        if template_line.startswith("title:::"):
+            success, updated_content = process_title(
+                template_line,
+                filename,
+            )
+            if not success:
+                return success
+
+            content += updated_content
+            continue
+
+        if "help:::" in template_line:
+            if help_function is None:
+                logger.error("help_function not found.")
+                return False
+
+            success, updated_content = process_help(
+                template_line,
+                help_function,
+            )
+            if not success:
+                return success
+
+            content += updated_content
+            continue
+
+        content_section = [template_line]
+        if template_line.startswith("```mermaid"):
+            mermaid_started = True
+            logger.info("🧜🏽‍♀️  detected ...")
+        elif mermaid_started and template_line.startswith("```"):
+            mermaid_started = False
+        elif mermaid_started:
+            if '"' in template_line and ":::folder" not in template_line:
+                content_section = process_mermaid(template_line)
+        else:
+            for macro, macro_value in macros.items():
+                if macro not in template_line:
+                    continue
 
-                    logger.info(f"+= help: {help_command}")
-                    print(help_content)
+                if template_line.replace(macro, "").strip():
+                    # this and that macro::: is going to be ...
                     content_section = [
-                        "```bash",
-                        help_content,
-                        "```",
+                        template_line.replace(
+                            macro,
+                            (
+                                " ".join(macro_value)
+                                if isinstance(macro_value, list)
+                                else macro_value
+                            ),
+                        )
                     ]
-            else:
-                for macro, macro_value in macros.items():
-                    if macro in template_line:
-                        content_section = macro_value
-                        break
+                else:
+                    # macro:::
+                    content_section = (
+                        macro_value if isinstance(macro_value, list) else [macro_value]
+                    )
+                    break
 
         content += content_section
 
+    content = process_national_internet(
+        filename,
+        content,
+    )
+
     return file.save_text(filename, content)

bluer_objects/README/items.py

@@ -1,17 +1,43 @@
 from typing import List, Dict
 
 
+# {image,jpg : url}
+def ImageItems(items: Dict[str, str]) -> List[str]:
+    def add_raw(url: str) -> str:
+        return (
+            f"{url}?raw=true" if "github.com" in url and "raw=true" not in url else url
+        )
+
+    return [
+        (
+            ""
+            if not image
+            else "[![image]({})]({})".format(
+                add_raw(image), url if url else add_raw(image)
+            )
+        )
+        for image, url in items.items()
+    ]
+
+
 # name, url, marquee, description
 def Items(
     items: List[Dict[str, str]],
+    sort: bool = False,
 ) -> List[str]:
-    return [
+    output = [
         (
-            "[`{}`]({}) [![image]({})]({}) {}".format(
-                item["name"],
-                item.get(
-                    "url",
-                    "#",
+            "{}[![image]({})]({}) {}".format(
+                (
+                    "[`{}`]({}) ".format(
+                        item["name"],
+                        item.get(
+                            "url",
+                            "#",
+                        ),
+                    )
+                    if item["name"]
+                    else ""
                 ),
                 item.get(
                     "marquee",
@@ -28,3 +54,49 @@ def Items(
         )
         for item in items
     ]
+
+    if sort:
+        output = sorted(output)
+
+    return output
+
+
+# dict of {name, url, marquee, description}
+def Items_of_dict(
+    dict_of_things: Dict[str, Dict],
+) -> List[str]:
+    return Items(
+        sorted(
+            [
+                {
+                    "order": info.get("order", thing_name),
+                    "name": thing_name,
+                    "marquee": info.get("marquee", ""),
+                    "url": f"./{thing_name}.md",
+                }
+                for thing_name, info in dict_of_things.items()
+                if thing_name != "template"
+            ],
+            key=lambda x: x["order"],
+        )
+    )
+
+
+# dict of {name, url, marquee, description}
+def list_of_dict(
+    dict_of_things: Dict[str, Dict],
+) -> List[str]:
+    return [
+        item["text"]
+        for item in sorted(
+            [
+                {
+                    "text": f"- [{thing_name}](./{thing_name}.md)",
+                    "order": info.get("order", thing_name),
+                }
+                for thing_name, info in dict_of_things.items()
+                if thing_name != "template"
+            ],
+            key=lambda x: x["order"],
+        )
+    ]

bluer_objects/README/process/assets.py

@@ -0,0 +1,36 @@
+from bluer_objects import file
+
+
+def process_assets(
+    template_line: str,
+    assets_repo: str,
+) -> str:
+    prefix = f"https://github.com/{assets_repo}/blob/main"
+
+    if "assets:::" in template_line:
+        template_line = " ".join(
+            [
+                (
+                    (
+                        "![image]({}/{}?raw=true)".format(
+                            prefix,
+                            token.split(":::")[1].strip(),
+                        )
+                        if any(
+                            token.endswith(extension)
+                            for extension in ["png", "jpg", "jpeg", "gif"]
+                        )
+                        else "[{}]({}/{})".format(
+                            file.name_and_extension(token.split(":::")[1].strip()),
+                            prefix,
+                            token.split(":::")[1].strip(),
+                        )
+                    )
+                    if token.startswith("assets:::")
+                    else token
+                )
+                for token in template_line.split(" ")
+            ]
+        )
+
+    return template_line

bluer_objects/README/process/details.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+def process_details(template_line: str) -> List[str]:
+    suffix = template_line.split(":::", 1)[1]
+    if suffix:
+        content_section = [
+            "",
+            "<details>",
+            f"<summary>{suffix}</summary>",
+            "",
+        ]
+    else:
+        content_section = [
+            "",
+            "</details>",
+            "",
+        ]
+
+    return content_section

bluer_objects/README/process/envs.py

@@ -0,0 +1,23 @@
+from bluer_options.env import get_env
+
+from bluer_objects.logger import logger
+
+
+def process_envs(template_line: str) -> str:
+    while "env:::" in template_line:
+        env_name = template_line.split("env:::", 1)[1]
+        if " " in env_name:
+            env_name = env_name.split(" ", 1)[0]
+        else:
+            if ":::" in env_name:
+                env_name = env_name.split(":::", 1)[0]
+
+        env_value = get_env(env_name)
+
+        template_line = template_line.replace(
+            f"env:::{env_name}",
+            env_value,
+        )
+        logger.info(f"{env_name} -> {env_value}")
+
+    return template_line

bluer_objects/README/process/help.py

@@ -0,0 +1,27 @@
+from typing import List, Union, Callable, Tuple
+
+from bluer_objects.logger import logger
+
+
+def process_help(
+    template_line: str,
+    help_function: Union[Callable[[List[str]], str], None] = None,
+) -> Tuple[bool, List[str]]:
+    help_command = template_line.split("help:::")[1].strip()
+
+    tokens = help_command.strip().split(" ")[1:]
+
+    help_content = help_function(tokens)
+    if not help_content:
+        logger.error(f"help not found: {help_command}: {tokens}")
+        return False, []
+
+    logger.info(f"+= help: {help_command}")
+    print(help_content)
+    content_section = [
+        "```bash",
+        help_content,
+        "```",
+    ]
+
+    return True, content_section