bluer-objects 6.3.1__py3-none-any.whl

bluer_objects/mysql/cache/functions.py

@@ -0,0 +1,181 @@
+from typing import Any, Dict, List
+from functools import reduce
+import json
+
+from blue_options import string
+
+from bluer_objects.mysql.table import Table
+from bluer_objects.logger import logger
+
+
+columns = "keyword,value,timestamp".split(",")
+
+
+def create() -> bool:
+    return Table.Create(
+        "cache",
+        [
+            "keyword VARCHAR(1024) NOT NULL",
+            "value VARCHAR(4096) NOT NULL",
+        ],
+    )
+
+
+def clone(
+    source: str,
+    destination: str,
+) -> bool:
+    lut = search(f"{source}.%")
+
+    lut = {
+        "{}.{}".format(
+            destination,
+            string.after(
+                keyword,
+                f"{source}.",
+            ),
+        ): value
+        for keyword, value in lut.items()
+    }
+
+    return reduce(
+        lambda x, y: x and y,
+        [write(keyword, value) for keyword, value in lut.items()],
+        True,
+    )
+
+
+def read(
+    keyword: str,
+    all: bool = False,
+    dataframe: bool = False,
+    like: bool = False,
+    unique: bool = False,
+) -> Any:
+    if dataframe:
+        all = True
+
+    table = Table(name="cache")
+
+    if isinstance(keyword, list):
+        keyword = ".".join(keyword)
+
+    if not table.connect():
+        return None
+
+    success, output = table.execute(
+        (
+            "SELECT {} FROM ".format(
+                ",".join(["c.{}".format(column) for column in columns])
+            )
+            + "abcli.cache c "
+        )
+        + (
+            (
+                "INNER JOIN ( "
+                "SELECT keyword, MAX(timestamp) AS max_timestamp "
+                "From abcli.cache "
+                "GROUP BY keyword "
+                ") cm ON c.keyword = cm.keyword AND c.timestamp = cm.max_timestamp "
+            )
+            if unique
+            else ""
+        )
+        + (
+            "WHERE c.keyword {} '{}' ".format("like" if like else "=", keyword)
+            + "ORDER BY c.timestamp DESC "
+            + "{};".format(
+                "" if all else "LIMIT 1",
+            )
+        )
+    )
+    if not success:
+        return None
+
+    if not table.disconnect():
+        return None
+
+    output = [
+        {keyword: item for keyword, item in zip(columns, thing)} for thing in output
+    ]
+
+    if not dataframe:
+        output = [item["value"] for item in output]
+
+    if not all:
+        output = "" if not output else output[0]
+
+    if dataframe:
+        import pandas as pd
+
+        output = pd.DataFrame.from_dict(output)
+
+    return output
+
+
+def search(keyword: str) -> Dict[str, str]:
+    table = Table(name="cache")
+
+    if isinstance(keyword, list):
+        keyword = ".".join(keyword)
+
+    if not table.connect():
+        return {}
+
+    success, output = table.execute(
+        "SELECT keyword,value FROM abcli.cache "
+        f"WHERE keyword like '{keyword}' "
+        "ORDER BY timestamp ASC;"
+    )
+
+    if success:
+        success = table.disconnect()
+
+    return {thing[0]: thing[1] for thing in output} if success else {}
+
+
+def search_value(value: str) -> List[str]:
+    table = Table(name="cache")
+
+    if not table.connect():
+        return []
+
+    success, output = table.execute(
+        "SELECT keyword,value FROM abcli.cache "
+        f"WHERE value = '{value}' "
+        "ORDER BY timestamp DESC;"
+    )
+
+    if success:
+        success = table.disconnect()
+
+    return [thing[0] for thing in output] if success else []
+
+
+def write(
+    keyword: str,
+    value: str,
+) -> bool:
+    table = Table(name="cache")
+
+    if isinstance(keyword, list):
+        keyword = ".".join(keyword)
+
+    if isinstance(value, dict):
+        value = json.dumps(value)
+
+    if not table.connect():
+        return False
+
+    success = table.insert(
+        ["keyword", "value"],
+        [keyword, value],
+    )
+
+    if success:
+        success = table.disconnect()
+
+    if success:
+        logger.info("cache[{}] <- {}".format(keyword, value))
+
+    return success

bluer_objects/mysql/relations/__init__.py

@@ -0,0 +1,9 @@
+from bluer_objects.mysql.relations.functions import (
+    clone,
+    create,
+    get,
+    search,
+    set_,
+    inverse_of,
+    list_of,
+)

bluer_objects/mysql/relations/__main__.py

@@ -0,0 +1,138 @@
+import argparse
+
+from blueness import module
+from blueness.argparse.generic import sys_exit
+
+from bluer_objects import file, NAME
+from bluer_objects.mysql.relations.functions import (
+    clone,
+    create,
+    get,
+    search,
+    set_,
+    inverse_of,
+    list_of,
+)
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    default="get",
+    help="clone|create|get|list|search|set",
+)
+parser.add_argument(
+    "--count",
+    type=int,
+    default=-1,
+)
+parser.add_argument(
+    "--delim",
+    type=str,
+    default=", ",
+)
+parser.add_argument(
+    "--filename",
+    type=str,
+)
+parser.add_argument(
+    "--item_name",
+    default="object",
+    type=str,
+)
+parser.add_argument(
+    "--log",
+    default=1,
+    type=int,
+    help="0|1",
+)
+parser.add_argument(
+    "--object_1",
+    type=str,
+)
+parser.add_argument(
+    "--object_2",
+    type=str,
+)
+parser.add_argument(
+    "--relation",
+    default="",
+    type=str,
+)
+parser.add_argument(
+    "--return_list",
+    type=int,
+    default=0,
+)
+args = parser.parse_args()
+
+delim = " " if args.delim == "space" else args.delim
+
+success = False
+if args.task == "clone":
+    success = clone(args.object_1, args.object_2)
+elif args.task == "create":
+    success = create()
+elif args.task == "get":
+    relation = get(args.object_1, args.object_2)
+    if args.log:
+        logger.info(
+            f"{args.object_1} -{f'{relation}->' if relation else 'X-'} {args.object_2}"
+        )
+    else:
+        print(relation)
+    success = True
+elif args.task == "list":
+    if args.return_list:
+        output = [relation for relation in list_of if relation]
+
+        if args.count != -1:
+            output = output[: args.count]
+
+        if args.log:
+            logger.info(f"{len(output):,} relations(s): {delim.join(output)}")
+        else:
+            print(delim.join(output))
+    else:
+        if args.log:
+            for thing in sorted(
+                [
+                    "{} : {}".format(this, that)
+                    for this, that in inverse_of.items()
+                    if this
+                ]
+            ):
+                logger.info(thing)
+        else:
+            print(
+                delim.join(
+                    [
+                        "{}:{}".format(this, that)
+                        for this, that in inverse_of.items()
+                        if this
+                    ]
+                )
+            )
+    success = True
+elif args.task == "search":
+    output = search(args.object_1, args.relation, args.count)
+
+    if args.relation:
+        if args.log:
+            logger.info(f"{len(output):,} {args.item_name}(s): {delim.join(output)}")
+        else:
+            print(delim.join(output))
+    else:
+        print(output)
+
+    success = file.save_json(args.filename, output) if args.filename else True
+elif args.task == "set":
+    success = set_(args.object_1, args.object_2, args.relation)
+else:
+    success = None
+
+sys_exit(logger, NAME, args.task, success, log=args.log)

bluer_objects/mysql/relations/functions.py

@@ -0,0 +1,180 @@
+import os
+from typing import Union, Dict, List
+from functools import reduce
+
+from bluer_objects import file
+from bluer_objects.mysql.table import Table
+from bluer_objects.logger import logger
+
+
+_, inverse_of = file.load_json(
+    os.path.join(
+        file.path(__file__),
+        "relations.json",
+    )
+)
+inverse_of.update({inverse_of[relation]: relation for relation in inverse_of})
+inverse_of[""] = ""
+
+list_of = sorted(list(set(list(inverse_of.keys()) + list(inverse_of.values()))))
+
+
+columns = "object_1,object_2,relation,timestamp".split(",")
+
+
+def clone(
+    object_1: str,
+    object_2: str,
+) -> bool:
+    return reduce(
+        lambda x, y: x and y,
+        [
+            reduce(
+                lambda x, y: x and y,
+                [set_(object_2, object, relation) for object in object_list],
+                True,
+            )
+            for relation, object_list in search(object_1).items()
+        ],
+        True,
+    )
+
+
+def create() -> bool:
+    return Table.Create(
+        "relations",
+        [
+            "object_1 VARCHAR(256) NOT NULL",
+            "object_2 VARCHAR(256) NOT NULL",
+            "relation VARCHAR(256) NOT NULL",
+        ],
+    )
+
+
+def get(
+    object_1: str,
+    object_2: str,
+) -> str:
+    if object_1 > object_2:
+        return inverse_of[get(object_1=object_2, object_2=object_1)]
+
+    table = Table(name="relations")
+
+    if not table.connect():
+        return ""
+
+    success, output = table.execute(
+        "SELECT r.relation "
+        "FROM abcli.relations r "
+        "INNER JOIN ( "
+        "SELECT MAX(timestamp) AS max_timestamp "
+        "FROM abcli.relations "
+        f'WHERE object_1="{object_1}" AND object_2="{object_2}" '
+        ") rm "
+        "ON r.timestamp=rm.max_timestamp "
+        f'WHERE object_1="{object_1}" AND object_2="{object_2}";'
+    )
+    if not success:
+        return ""
+
+    if not table.disconnect():
+        return ""
+
+    return "" if not output else output[-1][0]
+
+
+def search(
+    object: str,
+    relation: str = "",
+    count: int = -1,
+) -> Union[
+    Dict[str, List[str]],
+    List[str],
+]:
+    table = Table(name="relations")
+
+    output = [] if relation else {}
+
+    if not table.connect():
+        return output
+
+    success, output_right = table.execute(
+        "SELECT r.relation, r.object_2 "
+        "FROM abcli.relations r "
+        "INNER JOIN (  "
+        "SELECT object_2, MAX(timestamp) AS max_timestamp "
+        "FROM abcli.relations "
+        f'WHERE object_1="{object}" GROUP BY object_2'
+        ") rm  "
+        "ON r.timestamp=rm.max_timestamp "
+        f'WHERE object_1="{object}"; '
+    )
+    if not success:
+        return {}
+
+    success, output_left = table.execute(
+        "SELECT r.relation, r.object_1 "
+        "FROM abcli.relations r "
+        "INNER JOIN (  "
+        "SELECT object_1, MAX(timestamp) AS max_timestamp "
+        "FROM abcli.relations "
+        f'WHERE object_2="{object}" GROUP BY object_1'
+        ") rm  "
+        "ON r.timestamp=rm.max_timestamp "
+        f'WHERE object_2="{object}"; '
+    )
+    if not success:
+        return output
+
+    if not table.disconnect():
+        return output
+
+    raw_output = {thing[1]: thing[0] for thing in output_right}
+    raw_output.update({thing[1]: inverse_of[thing[0]] for thing in output_left})
+
+    raw_output = {thing: relation for thing, relation in raw_output.items() if relation}
+
+    output = {}
+    for object_, relation_ in raw_output.items():
+        output[relation_] = output.get(relation_, []) + [object_]
+
+    if not relation:
+        return output
+
+    output = output.get(relation, [])
+
+    if count != -1:
+        output = output[-count:]
+
+    return output
+
+
+def set_(
+    object_1: str,
+    object_2: str,
+    relation: str,
+) -> bool:
+    if relation not in list_of:
+        logger.error(f"-relations: set: {relation}: relation not found.")
+        return False
+
+    if object_1 > object_2:
+        return set_(object_2, object_1, inverse_of[relation])
+
+    table = Table(name="relations")
+
+    if not table.connect():
+        return False
+
+    if not table.insert(
+        ["object_1", "object_2", "relation"],
+        [object_1, object_2, relation],
+    ):
+        return False
+
+    if not table.disconnect():
+        return False
+
+    logger.info("{} ={}=> {}".format(object_1, relation if relation else "X", object_2))
+
+    return True

bluer_objects/mysql/table.py

@@ -0,0 +1,144 @@
+from typing import List, Union, Tuple, Any
+import pymysql
+
+from blueness import module
+
+from bluer_objects import NAME
+from bluer_objects.env import (
+    ABCLI_AWS_RDS_DB,
+    ABCLI_AWS_RDS_PORT,
+    ABCLI_AWS_RDS_USER,
+    ABCLI_AWS_RDS_HOST,
+    ABCLI_AWS_RDS_PASSWORD,
+)
+from blue_options.logger import crash_report
+
+NAME = module.name(__file__, NAME)
+
+
+class Table:
+    def __init__(self, name):
+        self.name = name
+
+        self.db = ABCLI_AWS_RDS_DB
+        self.port = int(ABCLI_AWS_RDS_PORT)
+        self.user = ABCLI_AWS_RDS_USER
+
+        self.host = ABCLI_AWS_RDS_HOST
+        self.password = ABCLI_AWS_RDS_PASSWORD
+
+        self.connection = None
+
+    def connect(
+        self,
+        create_command: str = "",
+    ) -> bool:
+        if self.connection is not None:
+            self.disconnect()
+
+        try:
+            self.connection = pymysql.connect(
+                host=self.host,
+                user=self.user,
+                port=self.port,
+                password=self.password,
+                database=self.db,
+            )
+        except:
+            crash_report(f"-{NAME}: connect: failed on host: {self.host}.")
+            return False
+
+        return True if not create_command else self.create(create_command)
+
+    @staticmethod
+    def Create(
+        table_name: str,
+        create_command: List[str],
+    ) -> bool:
+        table = Table(name=table_name)
+
+        return table.disconnect() if table.connect(create_command) else False
+
+    def create(
+        self,
+        create_command: List[str],
+    ) -> bool:
+        return self.execute(
+            "CREATE TABLE IF NOT EXISTS {} ({})".format(
+                self.name,
+                ",".join(
+                    [
+                        "id INT(24) NOT NULL AUTO_INCREMENT",
+                        "timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+                    ]
+                    + create_command
+                    + ["PRIMARY KEY (`id`)", "INDEX `index_timestamp` (`timestamp`)"]
+                ),
+            ),
+            commit=True,
+        )
+
+    def disconnect(self) -> bool:
+        if self.connection is None:
+            return True
+
+        success = True
+        try:
+            self.connection.close()
+        except:
+            crash_report(f"-{NAME}: disconnect: failed.")
+            success = False
+
+        self.connection = None
+        return success
+
+    def drop(self) -> bool:
+        return self.execute(f"DROP table {self.name};")
+
+    def execute(
+        self,
+        sql: str,
+        commit: bool = False,
+        returns_output: bool = True,
+    ) -> Union[bool, Tuple[bool, Any]]:
+        output = []
+        success = False
+        try:
+            with self.connection.cursor() as cursor:
+                if isinstance(sql, tuple):
+                    cursor.execute(sql[0], sql[1])
+                else:
+                    cursor.execute(sql)
+
+                if returns_output:
+                    output = cursor.fetchall()
+
+                if commit:
+                    # connection is not autocommit by default. So you must commit to save
+                    # your changes.
+                    self.connection.commit()
+
+            success = True
+        except:
+            crash_report(f"-{NAME}: execute({sql}): failed.")
+
+        return (success, output) if returns_output else success
+
+    def insert(
+        self,
+        columns: List[str],
+        values: List[Any],
+    ) -> bool:
+        return self.execute(
+            (
+                f"INSERT INTO {self.name}"
+                + " ("
+                + ", ".join(columns)
+                + ") VALUES ("
+                + ", ".join(len(columns) * ["%s"])
+                + ")",
+                values,
+            ),
+            commit=True,
+            returns_output=True,
+        )

bluer_objects/mysql/tags/__init__.py

@@ -0,0 +1 @@
+from bluer_objects.mysql.tags.functions import clone, create, get, search, set_