bluer-objects 6.5.1__py3-none-any.whl → 6.6.1__py3-none-any.whl

bluer_objects/mysql/table.py

@@ -1,144 +0,0 @@
-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

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

bluer_objects/mysql/tags/__main__.py

@@ -1,130 +0,0 @@
-import argparse
-
-from blueness import module
-from blueness.argparse.generic import sys_exit
-
-from bluer_objects import NAME
-from bluer_objects.mysql.tags.functions import clone, create, get, search, set_
-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|search|set",
-)
-parser.add_argument(
-    "--after",
-    type=str,
-    default="",
-    help="123-4-e",
-)
-parser.add_argument(
-    "--before",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--count",
-    type=int,
-    default=-1,
-)
-parser.add_argument(
-    "--offset",
-    type=int,
-    default=0,
-)
-parser.add_argument(
-    "--delim",
-    type=str,
-    default=", ",
-)
-parser.add_argument(
-    "--host",
-    default=-1,
-    type=int,
-    help="0|1|-1",
-)
-parser.add_argument(
-    "--item_name",
-    default="object",
-    type=str,
-)
-parser.add_argument(
-    "--log",
-    default=1,
-    type=int,
-    help="0|1",
-)
-parser.add_argument(
-    "--object",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--object_2",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--shuffle",
-    default=0,
-    type=int,
-    help="0|1",
-)
-parser.add_argument(
-    "--tag",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--tags",
-    type=str,
-    default="",
-    help="tag_1,~tag_2",
-)
-parser.add_argument(
-    "--type",
-    type=str,
-    default="",
-)
-args = parser.parse_args()
-
-delim = " " if args.delim == "space" else args.delim
-
-success = False
-output = None
-if args.task == "clone":
-    success = clone(args.object, args.object_2)
-elif args.task == "create":
-    success = create()
-elif args.task == "get":
-    output = get(args.object)
-    success = True
-elif args.task == "search":
-    output = search(
-        args.tags,
-        after=args.after,
-        before=args.before,
-        count=args.count,
-        host=args.host,
-        shuffle=args.shuffle,
-        offset=args.offset,
-    )
-    success = True
-elif args.task == "set":
-    success = set_(args.object, args.tags)
-else:
-    success = None
-
-if success is True and output is not None:
-    if args.log:
-        logger.info(f"{len(output):,} {args.item_name}(s): {delim.join(output)}")
-    else:
-        print(delim.join(output))
-
-sys_exit(logger, NAME, args.task, success, log=args.log)

bluer_objects/mysql/tags/functions.py

@@ -1,203 +0,0 @@
-from typing import List
-from functools import reduce
-import random
-import re
-
-from blue_options.options import Options
-
-from bluer_objects.mysql.table import Table
-from bluer_objects.logger import logger
-
-
-def clone(
-    object_1: str,
-    object_2: str,
-) -> bool:
-    return set_(object_2, get(object_1))
-
-
-def create() -> bool:
-    return Table.Create(
-        "tags",
-        [
-            "keyword VARCHAR(256) NOT NULL",
-            "tag VARCHAR(4096) NOT NULL",
-            "value BIT NOT NULL",
-        ],
-    )
-
-
-def get(keyword: str) -> List[str]:
-    table = Table(name="tags")
-
-    if not table.connect():
-        return []
-
-    success, output = table.execute(
-        "SELECT t.tag,t.value "
-        f"FROM {table.name} t "
-        "INNER JOIN ( "
-        "SELECT tag, MAX(timestamp) AS max_timestamp "
-        f"FROM {table.name} "
-        f'WHERE keyword="{keyword}" GROUP BY tag '
-        ") tm "
-        "ON t.tag=tm.tag AND t.timestamp=tm.max_timestamp "
-        f'WHERE keyword="{keyword}";',
-    )
-
-    if success:
-        success = table.disconnect()
-
-    if not success:
-        return []
-
-    return sorted([thing[0] for thing in output if thing[1] == b"\x01"])
-
-
-def search(
-    tags: List[str],
-    after: str = "",
-    before: str = "",
-    count: int = -1,
-    host: int = -1,  # limit to/exclude/ignore (1/0/-1) hosts.
-    return_timestamp: bool = False,
-    shuffle: bool = False,
-    offset: int = 0,
-) -> List[str]:
-    if isinstance(tags, str):
-        tags = tags.split(",")
-
-    included_tags = []
-    excluded_tags = []
-    for tag in tags:
-        if tag:
-            if tag[0] in "~-!":
-                excluded_tags += [tag[1:]]
-            else:
-                included_tags += [tag]
-
-    table = Table(name="tags")
-
-    table.connect()
-
-    list_of_keywords = None
-    timestamp = {}
-    for tag in included_tags:
-        success, output = table.execute(
-            "SELECT t.keyword,t.value,t.timestamp "
-            "FROM abcli.tags t "
-            "INNER JOIN ( "
-            "SELECT keyword, MAX(timestamp) AS max_timestamp "
-            "FROM abcli.tags "
-            f'WHERE tag="{tag}" GROUP BY keyword '
-            ") tm "
-            "ON t.keyword=tm.keyword AND t.timestamp=tm.max_timestamp "
-            f'WHERE tag="{tag}"; '
-        )
-        if not success:
-            list_of_keywords = []
-            break
-
-        list_of_keywords_ = [thing[0] for thing in output if thing[1] == b"\x01"]
-
-        if return_timestamp:
-            for thing in output:
-                if thing[1] == b"\x01":
-                    timestamp[thing[0]] = thing[2]
-
-        list_of_keywords = (
-            list_of_keywords_
-            if list_of_keywords is None
-            else [
-                keyword for keyword in list_of_keywords if keyword in list_of_keywords_
-            ]
-        )
-
-    table.disconnect()
-
-    list_of_keywords = [] if list_of_keywords is None else sorted(list_of_keywords)
-
-    if after:
-        list_of_keywords = [keyword for keyword in list_of_keywords if keyword >= after]
-
-    if before:
-        list_of_keywords = [
-            keyword for keyword in list_of_keywords if keyword <= before
-        ]
-
-    excluded_keywords = reduce(
-        lambda x, y: x + y,
-        [
-            search(
-                tag,
-                after=after,
-                before=before,
-                count=-1,
-                host=host,
-            )
-            for tag in excluded_tags
-        ],
-        [],
-    )
-
-    list_of_keywords = [
-        keyword for keyword in list_of_keywords if keyword not in excluded_keywords
-    ]
-
-    if shuffle:
-        random.shuffle(list_of_keywords)
-    else:
-        list_of_keywords = list_of_keywords[::-1]
-
-    p = re.compile("([0-9]{13}|(0|1)[0-9,a-z]{15}|i-[0-9,a-z]{17})")
-    if host == 1:
-        list_of_keywords = [keyword for keyword in list_of_keywords if p.match(keyword)]
-    if host == 0:
-        list_of_keywords = [
-            keyword for keyword in list_of_keywords if not p.match(keyword)
-        ]
-
-    list_of_keywords = list_of_keywords[offset:]
-
-    list_of_keywords = (
-        list_of_keywords[:count]
-        if count > 0
-        else [] if count != -1 else list_of_keywords
-    )
-
-    return (list_of_keywords, timestamp) if return_timestamp else list_of_keywords
-
-
-def set_(
-    keyword: str,
-    tags: List[str],
-) -> bool:
-    table = Table(name="tags")
-
-    if isinstance(tags, list):
-        tags = ",".join(tags)
-    if isinstance(tags, str):
-        tags = Options(tags)
-
-    if not table.connect():
-        return False
-
-    tags = {tag.strip(): value for tag, value in tags.items()}
-
-    success = True
-    for tag in tags:
-        if not table.insert(
-            "keyword,tag,value".split(","),
-            [keyword, tag, 1 if tags[tag] else 0],
-        ):
-            success = False
-        else:
-            if tags[tag]:
-                logger.info(f"{keyword} += #{tag}.")
-            else:
-                logger.info(f"{keyword} -= #{tag}.")
-
-    if not table.disconnect():
-        return False
-
-    return success

bluer_objects/storage/__init__.py

@@ -1,3 +0,0 @@
-from bluer_objects.storage.classes import Storage
-
-instance = Storage()

bluer_objects/storage/__main__.py

@@ -1,114 +0,0 @@
-import argparse
-
-from blueness import module
-from blueness.argparse.generic import sys_exit
-
-from bluer_objects import NAME
-from bluer_objects.env import ABCLI_AWS_S3_BUCKET_NAME
-from bluer_objects.storage.classes import Storage
-from bluer_objects.logger import logger
-
-NAME = module.name(__file__, NAME)
-
-
-parser = argparse.ArgumentParser(NAME)
-parser.add_argument(
-    "task",
-    type=str,
-    default="",
-    help="create_bucket|download_file|exists|list_of_objects|upload_file",
-)
-parser.add_argument(
-    "--filename",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--bucket_name",
-    type=str,
-    default=ABCLI_AWS_S3_BUCKET_NAME,
-)
-parser.add_argument(
-    "--count",
-    type=int,
-    default=9999,
-)
-parser.add_argument(
-    "--delim",
-    type=str,
-    default=", ",
-)
-parser.add_argument(
-    "--item_name",
-    default="object",
-    type=str,
-)
-parser.add_argument(
-    "--log",
-    default=1,
-    type=int,
-    help="0|1",
-)
-parser.add_argument(
-    "--object_name",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--prefix",
-    type=str,
-    default="",
-)
-parser.add_argument(
-    "--recursive",
-    type=int,
-    default=1,
-    help="0|1",
-)
-parser.add_argument(
-    "--suffix",
-    type=str,
-    default="",
-)
-
-args = parser.parse_args()
-
-delim = " " if args.delim == "space" else args.delim
-
-success = True
-output = None
-if args.task == "create_bucket":
-    success = Storage(args.bucket_name).s3 is not None
-elif args.task == "download_file":
-    success = Storage(args.bucket_name).download_file(
-        bucket_name=args.bucket_name,
-        object_name=args.object_name,
-        filename=args.filename,
-    )
-elif args.task == "exists":
-    print(Storage(args.bucket_name).exists(args.object_name))
-    success = True
-elif args.task == "list_of_objects":
-    output = Storage(args.bucket_name).list_of_objects(
-        count=args.count,
-        suffix=args.suffix,
-        prefix=args.prefix,
-        recursive=args.recursive,
-    )
-    success = True
-elif args.task == "upload_file":
-    success = Storage(args.bucket_name).upload_file(
-        filename=args.filename,
-        object_name=args.object_name,
-        bucket_name=args.bucket_name,
-    )
-else:
-    print(f"{NAME}: {args.task}: command not found.")
-
-if success and output is not None:
-    if args.log:
-        print(f"{len(output):,} {args.item_name}(s): {delim.join(output)}")
-    else:
-        print(delim.join(output))
-
-sys_exit(logger, NAME, args.task, success, log=args.log)