masonite-framework-orm 3.0.1__py3-none-any.whl

masoniteorm/commands/ShellCommand.py

@@ -0,0 +1,205 @@
+import os
+import re
+import shlex
+import subprocess
+from collections import OrderedDict
+
+from ..config import load_config
+from .Command import Command
+
+
+class ShellCommand(Command):
+    """
+    Connect to your database interactive terminal.
+
+    shell
+        {--c|connection=default : The connection you want to use to connect to interactive terminal}
+        {--s|show=? : Display the command which will be called to connect}
+    """
+
+    shell_programs = {
+        "mysql": "mysql",
+        "postgres": "psql",
+        "sqlite": "sqlite3",
+        "mssql": "sqlcmd",
+    }
+
+    def handle(self):
+        resolver = load_config(self.option("config")).DB
+        connection = self.option("connection")
+        if connection == "default":
+            connection = resolver.get_connection_details()["default"]
+        config = resolver.get_connection_information(connection)
+        if not config.get("full_details"):
+            self.line(
+                f"<error>Connection configuration for '{connection}' not found !</error>"
+            )
+            exit(-1)
+
+        command, env = self.get_command(config)
+
+        if self.option("show"):
+            cleaned_command = self.hide_sensitive_options(config, command)
+            self.comment(cleaned_command)
+            self.line("")
+
+        # let shlex split command in a list as it's safer
+        command_args = shlex.split(command)
+        try:
+            subprocess.run(command_args, check=True, env=env)
+        except FileNotFoundError:
+            self.line(
+                f"<error>Cannot find {config.get('full_details').get('driver')} program ! Please ensure you can call this program in your shell first.</error>"
+            )
+            exit(-1)
+        except subprocess.CalledProcessError:
+            self.line("<error>An error happened calling the command.</error>")
+            exit(-1)
+
+    def get_shell_program(self, connection):
+        """Get the database shell program to run."""
+        return self.shell_programs.get(connection)
+
+    def get_command(self, config):
+        """Get the command to run as a string."""
+        driver = config.get("full_details").get("driver")
+        program = self.get_shell_program(driver)
+        try:
+            get_driver_args = getattr(self, f"get_{driver}_args")
+        except AttributeError:
+            self.line(
+                f"<error>Connecting with driver '{driver}' is not implemented !</error>"
+            )
+            exit(-1)
+        args, options = get_driver_args(config)
+        # process positional arguments
+        args = " ".join(args)
+        # process optional arguments
+        options = self.remove_empty_options(options)
+        options_string = " ".join(
+            f"{option} {value}" if value else option
+            for option, value in options.items()
+        )
+        # finally build command string
+        command = program
+        if args:
+            command += f" {args}"
+        if options_string:
+            command += f" {options_string}"
+
+        # prepare environment in which command will be run
+        # some drivers need to define env variable such as psql for specifying password
+        try:
+            driver_env = getattr(self, f"get_{driver}_env")(config)
+        except AttributeError:
+            driver_env = {}
+        command_env = {**os.environ.copy(), **driver_env}
+
+        return command, command_env
+
+    def get_mysql_args(self, config):
+        """Get command positional arguments and options for MySQL driver."""
+        args = [config.get("database")]
+        options = OrderedDict(
+            {
+                "--host": config.get("host"),
+                "--port": config.get("port"),
+                "--user": config.get("user"),
+                "--password": config.get("password"),
+                "--default-character-set": config.get("options", {}).get(
+                    "charset"
+                ),
+            }
+        )
+        return args, options
+
+    def get_postgres_args(self, config):
+        """Get command positional arguments and options for PostgreSQL driver."""
+        args = [config.get("database")]
+        options = OrderedDict(
+            {
+                "--host": config.get("host"),
+                "--port": config.get("port"),
+                "--username": config.get("user"),
+            }
+        )
+        return args, options
+
+    def get_postgres_env(self, config):
+        return {"PGPASSWORD": config.get("password")}
+
+    def get_mssql_args(self, config):
+        """Get command positional arguments and options for MSSQL driver."""
+        args = []
+
+        # instance of SQL Server: -S [protocol:]server[instance_name][,port]
+        server = f"tcp:{config.get('host')}"
+        if config.get("port"):
+            server += f",{config.get('port')}"
+
+        trusted_connection = (
+            config.get("options").get("trusted_connection") == "Yes"
+        )
+        options = OrderedDict(
+            {
+                "-d": config.get("database"),
+                "-U": config.get("user"),
+                "-P": config.get("password"),
+                "-S": server,
+                "-E": trusted_connection,
+                "-t": config.get("options", {}).get("connection_timeout"),
+            }
+        )
+        return args, options
+
+    def get_sqlite_args(self, config):
+        """Get command positional arguments and options for SQLite driver."""
+        args = [config.get("database")]
+        options = OrderedDict()
+        return args, options
+
+    def remove_empty_options(self, options):
+        """Remove empty options when value does not evaluate to True.
+        Also when value is exactly 'True' we don't want True to be passed as option value but
+        we want the option to be passed.
+        """
+        # remove empty options and remove value when option is True
+        cleaned_options = OrderedDict()
+        for key, value in options.items():
+            if value is True:
+                cleaned_options[key] = ""
+            elif value:
+                cleaned_options[key] = value
+        return cleaned_options
+
+    def get_sensitive_options(self, config):
+        driver = config.get("full_details").get("driver")
+        try:
+            sensitive_options = getattr(
+                self, f"get_{driver}_sensitive_options"
+            )()
+        except AttributeError:
+            sensitive_options = []
+        return sensitive_options
+
+    def get_mysql_sensitive_options(self):
+        return ["--password"]
+
+    def get_mssql_sensitive_options(self):
+        return ["-P"]
+
+    def hide_sensitive_options(self, config, command):
+        """Hide sensitive options in command string before it's displayed in the shell for
+        security reasons. All drivers can declare what options are considered sensitive, their
+        values will be then replaced by *** when displayed only."""
+        cleaned_command = command
+        sensitive_options = self.get_sensitive_options(config)
+        for option in sensitive_options:
+            # if option is used obfuscate its value
+            if option in command:
+                match = re.search(rf"{option} (\w+)", command)
+                if match.groups():
+                    cleaned_command = cleaned_command.replace(
+                        match.groups()[0], "***"
+                    )
+        return cleaned_command

masoniteorm/commands/__init__.py

@@ -0,0 +1,18 @@
+import os
+import sys
+
+sys.path.append(os.getcwd())
+
+from .MakeMigrationCommand import MakeMigrationCommand
+from .MakeModelCommand import MakeModelCommand
+from .MakeModelDocstringCommand import MakeModelDocstringCommand
+from .MakeObserverCommand import MakeObserverCommand
+from .MakeSeedCommand import MakeSeedCommand
+from .MigrateCommand import MigrateCommand
+from .MigrateFreshCommand import MigrateFreshCommand
+from .MigrateRefreshCommand import MigrateRefreshCommand
+from .MigrateResetCommand import MigrateResetCommand
+from .MigrateRollbackCommand import MigrateRollbackCommand
+from .MigrateStatusCommand import MigrateStatusCommand
+from .SeedRunCommand import SeedRunCommand
+from .ShellCommand import ShellCommand

masoniteorm/commands/stubs/create_migration.stub

@@ -0,0 +1,20 @@
+"""__MIGRATION_NAME__ Migration."""
+
+from masoniteorm.migrations import Migration
+
+
+class __MIGRATION_NAME__(Migration):
+    def up(self):
+        """
+        Run the migrations.
+        """
+        with self.schema.create("__TABLE_NAME__") as table:
+            table.increments("id")
+
+            table.timestamps()
+
+    def down(self):
+        """
+        Revert the migrations.
+        """
+        self.schema.drop("__TABLE_NAME__")

masoniteorm/commands/stubs/create_seed.stub

@@ -0,0 +1,9 @@
+"""__SEEDER_NAME__ Seeder."""
+
+from masoniteorm.seeds import Seeder
+
+
+class __SEEDER_NAME__(Seeder):
+    def run(self):
+        """Run the database seeds."""
+        pass

masoniteorm/commands/stubs/model.stub

@@ -0,0 +1,9 @@
+""" __CLASS__ Model """
+
+from masoniteorm.models import Model
+
+
+class __CLASS__(Model):
+    """__CLASS__ Model"""
+
+    pass

masoniteorm/commands/stubs/observer.stub

@@ -0,0 +1,101 @@
+"""__CLASS__ Observer"""
+
+from masoniteorm.models import Model
+
+
+class __CLASS__Observer:
+    def created(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "created" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def creating(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "creating" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def saving(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "saving" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def saved(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "saved" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def updating(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "updating" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def updated(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "updated" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def booted(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "booted" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def booting(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "booting" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def hydrating(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "hydrating" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def hydrated(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "hydrated" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def deleting(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "deleting" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass
+
+    def deleted(self, __MODEL_VARIABLE__):
+        """Handle the __MODEL__ "deleted" event.
+
+        Args:
+            __MODEL_VARIABLE__ (masoniteorm.models.Model): __MODEL__ model.
+        """
+        pass

masoniteorm/commands/stubs/table_migration.stub

@@ -0,0 +1,19 @@
+"""__MIGRATION_NAME__ Migration."""
+
+from masoniteorm.migrations import Migration
+
+
+class __MIGRATION_NAME__(Migration):
+    def up(self):
+        """
+        Run the migrations.
+        """
+        with self.schema.table("__TABLE_NAME__") as table:
+            pass
+
+    def down(self):
+        """
+        Revert the migrations.
+        """
+        with self.schema.table("__TABLE_NAME__") as table:
+            pass

masoniteorm/config.py

@@ -0,0 +1,123 @@
+import os
+import pydoc
+import urllib.parse as urlparse
+
+from .exceptions import ConfigurationNotFound, InvalidUrlConfiguration
+
+
+def load_config(config_path=None):
+    """Load ORM configuration from given configuration path (dotted or not).
+    If no path is provided:
+        1. try to load from DB_CONFIG_PATH environment variable
+        2. else try to load from default config_path: config/database
+    """
+    selected_config_path = (
+        os.getenv("DB_CONFIG_PATH", config_path) or "config/database"
+    )
+
+    os.environ["DB_CONFIG_PATH"] = selected_config_path
+
+    # format path as python module if needed
+    selected_config_path = (
+        selected_config_path.replace("/", ".").replace("\\", ".").rstrip(".py")
+    )
+    config_module = pydoc.locate(selected_config_path)
+    if config_module is None:
+        raise ConfigurationNotFound(
+            f"ORM configuration file has not been found in {selected_config_path}."
+        )
+    return config_module
+
+
+def db_url(database_url=None, prefix="", options={}, log_queries=False):
+    """Parse connection configuration from database url format. If no url is provided,
+    DATABASE_URL environment variable will be used instead.
+
+    Reference: Code adapted from https://github.com/jacobian/dj-database-url
+    """
+
+    url = database_url or os.getenv("DATABASE_URL")
+    if not url:
+        raise InvalidUrlConfiguration("Database url is empty !")
+
+    # Register database schemes in URLs.
+    urlparse.uses_netloc.append("postgres")
+    urlparse.uses_netloc.append("postgresql")
+    urlparse.uses_netloc.append("pgsql")
+    urlparse.uses_netloc.append("postgis")
+    urlparse.uses_netloc.append("mysql")
+    urlparse.uses_netloc.append("mysql2")
+    urlparse.uses_netloc.append("mysqlgis")
+    urlparse.uses_netloc.append("mssql")
+    urlparse.uses_netloc.append("sqlite")
+
+    DRIVERS_MAP = {
+        "postgres": "postgres",
+        "postgresql": "postgres",
+        "pgsql": "postgres",
+        "postgis": "postgres",
+        "mysql": "mysql",
+        "mysql2": "mysql",
+        "mysqlgis": "mysql",
+        "mysql-connector": "mysql",
+        "mssql": "mssql",
+        "sqlite": "sqlite",
+    }
+
+    # this is a special case, because if we pass this URL into
+    # urlparse, urlparse will choke trying to interpret "memory"
+    # as a port number
+    if url in ["sqlite://:memory:", "sqlite://memory"]:
+        driver = DRIVERS_MAP["sqlite"]
+        path = ":memory:"
+    # otherwise parse the url as normal
+    else:
+        url = urlparse.urlparse(url)
+        # remove query string from path (not parsed for now)
+        path = url.path[1:]
+        if "?" in path and not url.query:
+            path, _ = path.split("?", 2)
+
+        # if we are using sqlite and we have no path, then assume we
+        # want an in-memory database (this is the behaviour of sqlalchemy)
+        if url.scheme == "sqlite" and path == "":
+            path = ":memory:"
+
+        # handle postgres percent-encoded paths.
+        hostname = url.hostname or ""
+        if "%2f" in hostname.lower():
+            # Switch to url.netloc to avoid lower cased paths
+            hostname = url.netloc
+            if "@" in hostname:
+                hostname = hostname.rsplit("@", 1)[1]
+            if ":" in hostname:
+                hostname = hostname.split(":", 1)[0]
+            hostname = hostname.replace("%2f", "/").replace("%2F", "/")
+
+        # lookup specified driver
+        driver = DRIVERS_MAP[url.scheme]
+        port = (
+            str(url.port)
+            if url.port and driver in [DRIVERS_MAP["mssql"]]
+            else url.port
+        )
+
+    # build final configuration
+    config = {
+        "driver": driver,
+        "database": urlparse.unquote(path or ""),
+        "prefix": prefix,
+        "options": options,
+        "log_queries": log_queries,
+    }
+
+    if driver != DRIVERS_MAP["sqlite"]:
+        config.update(
+            {
+                "user": urlparse.unquote(url.username or ""),
+                "password": urlparse.unquote(url.password or ""),
+                "host": hostname,
+                "port": port or "",
+            }
+        )
+    return config

masoniteorm/connections/BaseConnection.py

@@ -0,0 +1,101 @@
+import logging
+from timeit import default_timer as timer
+
+from .ConnectionResolver import ConnectionResolver
+
+
+class BaseConnection:
+    _connection = None
+    _cursor = None
+    _dry = False
+
+    def dry(self):
+        self._dry = True
+        return self
+
+    def set_schema(self, schema):
+        self.schema = schema
+        return self
+
+    def log(
+        self,
+        query,
+        bindings,
+        query_time=0,
+        logger="masoniteorm.connections.queries",
+    ):
+        logger = logging.getLogger("masoniteorm.connection.queries")
+        logger.propagate = self.full_details.get("propagate", True)
+
+        logger.debug(
+            f"Running query {query}, {bindings}. Executed in {query_time}ms",
+            extra={
+                "query": query,
+                "bindings": bindings,
+                "query_time": query_time,
+            },
+        )
+
+    def statement(self, query, bindings=()):
+        """Wrapper around calling the cursor query. Helpful for logging output.
+
+        Args:
+            query (string): The query to execute on the cursor
+            bindings (tuple, optional): Tuple of query bindings. Defaults to ().
+        """
+        start = timer()
+        if not self._cursor:
+            raise AttributeError(
+                f"Must set the _cursor attribute on the {self.__class__.__name__} class before calling the 'statement' method."
+            )
+
+        self._cursor.execute(query, bindings)
+        end = "{:.2f}".format(timer() - start)
+
+        if self.full_details and self.full_details.get("log_queries", False):
+            self.log(query, bindings, query_time=end)
+
+    def has_global_connection(self):
+        return self.name in ConnectionResolver().get_global_connections()
+
+    def get_global_connection(self):
+        return ConnectionResolver().get_global_connections()[self.name]
+
+    def enable_query_log(self):
+        self.full_details["log_queries"] = True
+
+    def disable_query_log(self):
+        self.full_details["log_queries"] = False
+
+    def format_cursor_results(self, cursor_result):
+        return cursor_result
+
+    def set_cursor(self):
+        self._cursor = self._connection.cursor()
+        return self
+
+    def select_many(self, query, bindings, amount):
+        self.set_cursor()
+        self.statement(query)
+        if not self.open:
+            self.make_connection()
+
+        result = self.format_cursor_results(self._cursor.fetchmany(amount))
+        while result:
+            yield result
+
+            result = self.format_cursor_results(self._cursor.fetchmany(amount))
+
+    def get_row_count(self):
+        return self._cursor.rowcount
+
+    def enable_disable_foreign_keys(self):
+        foreign_keys = self.full_details.get("foreign_keys")
+        platform = self.get_default_platform()()
+
+        if foreign_keys:
+            self._connection.execute(platform.enable_foreign_key_constraints())
+        elif foreign_keys is not None:
+            self._connection.execute(
+                platform.disable_foreign_key_constraints()
+            )

masoniteorm/connections/ConnectionFactory.py

@@ -0,0 +1,59 @@
+from ..config import load_config
+from .ConnectionResolver import ConnectionResolver
+
+
+class ConnectionFactory:
+    """Class for controlling the registration and creation of connection types."""
+
+    _connections = {}
+
+    def __init__(self, config_path=None, resolver=None):
+        self.config_path = config_path
+        self._resolver: ConnectionResolver = resolver
+
+    @classmethod
+    def register(cls, key, connection):
+        """Registers new connections
+
+        Arguments:
+            key {key} -- The key or driver name you want assigned to this connection
+            connection {masoniteorm.connections.BaseConnection} -- An instance of a BaseConnection class.
+
+        Returns:
+            cls
+        """
+        cls._connections.update({key: connection})
+        return cls
+
+    def make(self, key):
+        """Makes already registered connections
+
+        Arguments:
+            key {string} -- The name of the connection you want to make
+
+        Raises:
+            Exception: Raises exception if there are no driver keys that match
+
+        Returns:
+            masoniteorm.connection.BaseConnection -- Returns an instance of a BaseConnection class.
+        """
+        if not self._resolver:
+            self._resolver = load_config(config_path=self.config_path).DB
+
+        connections = self._resolver.get_connection_details()
+        if key == "default":
+            connection_details = connections.get(connections.get("default"))
+            connection = self._connections.get(
+                connection_details.get("driver")
+            )
+        else:
+            connection = self._connections.get(key)
+
+        if connection:
+            return connection
+
+        raise Exception(
+            "The '{connection}' connection does not exist".format(
+                connection=key
+            )
+        )