sqlcompose 0.0.3__tar.gz → 0.0.4a2__tar.gz

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Dagrofa
+Copyright (c) 2025 Anders Madsen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{sqlcompose-0.0.3/src/sqlcompose.egg-info → sqlcompose-0.0.4a2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: sqlcompose
-Version: 0.0.3
-Summary: Composition of linked SQL files
+Version: 0.0.4a2
+Summary: Composition of SQL files
 Author-email: Anders Madsen <anders.madsen@alphavue.com>
-License: MIT
+License-Expression: MIT
 Project-URL: repository, https://github.com/apmadsen/sqlcompose
 Keywords: sql,composition,windows,linux
 Classifier: Development Status :: 5 - Production/Stable
@@ -18,39 +18,54 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
 Requires-Dist: pytest>=8.3.0; extra == "test"
 Requires-Dist: pytest-cov>=6.1.0; extra == "test"
+Requires-Dist: pytest-mock>=3.15; extra == "test"
 Dynamic: license-file
 
 [![Test](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml)
 [![Coverage](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml)
-![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)
+[![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/sqlcompose/releases)
 ![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/sqlcompose?label=pre-release&include_prereleases&sort=semver&color=blue)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlcompose)
+[![PyPI Downloads](https://static.pepy.tech/badge/sqlcompose/week)](https://pepy.tech/projects/sqlcompose)
 
+# sqlcompose: Composition of SQL files
+sqlcompose lets you to compose sql files from multiple files by introducing `$INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
 
-# sqlcompose: Composition of linked SQL files
-sqlcompose allows you to compose sql files from multiple files by introducing `INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
+Using composition, you reduce both complexity and duplication of code thus adhering to the DRY principle.
+
+### SQL Dialect
+sqlcompose outputs SQL as standard ANSI SQL. Note though, that no validation is done on either the input or the output.
 
 ## Examples
-__Execute the script directly:__
-```console
+
+### 1. Execute the script with the filename as an argument and output to the console:
+```bash
 sqlcompose query.sql
 ```
+
+### 2. Pipe data into application and output to a file
+```bash
+cat query.sql | sqlcompose > output.sql
+```
+
+### 3. Execute the script with SQL string as argument
 ```bash
-sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
-sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
+sqlcompose 'select * from $INCLUDE(included-query1.sql)'
 ```
+> NOTE: Different consoles have different limitations, so you may have to switch from single to double quotes to allow for using the dollar sign.
 
-__Import it in another script:__
+### 4. Import it in another python application or package
 ```python
 from sqlcompose import load, loads
 # method 1 : loading from a file

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/README.md

@@ -1,24 +1,37 @@
 [![Test](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml)
 [![Coverage](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml)
-![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)
+[![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/sqlcompose/releases)
 ![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/sqlcompose?label=pre-release&include_prereleases&sort=semver&color=blue)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlcompose)
+[![PyPI Downloads](https://static.pepy.tech/badge/sqlcompose/week)](https://pepy.tech/projects/sqlcompose)
 
+# sqlcompose: Composition of SQL files
+sqlcompose lets you to compose sql files from multiple files by introducing `$INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
 
-# sqlcompose: Composition of linked SQL files
-sqlcompose allows you to compose sql files from multiple files by introducing `INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
+Using composition, you reduce both complexity and duplication of code thus adhering to the DRY principle.
+
+### SQL Dialect
+sqlcompose outputs SQL as standard ANSI SQL. Note though, that no validation is done on either the input or the output.
 
 ## Examples
-__Execute the script directly:__
-```console
+
+### 1. Execute the script with the filename as an argument and output to the console:
+```bash
 sqlcompose query.sql
 ```
+
+### 2. Pipe data into application and output to a file
+```bash
+cat query.sql | sqlcompose > output.sql
+```
+
+### 3. Execute the script with SQL string as argument
 ```bash
-sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
-sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
+sqlcompose 'select * from $INCLUDE(included-query1.sql)'
 ```
+> NOTE: Different consoles have different limitations, so you may have to switch from single to double quotes to allow for using the dollar sign.
 
-__Import it in another script:__
+### 4. Import it in another python application or package
 ```python
 from sqlcompose import load, loads
 # method 1 : loading from a file

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/pyproject.toml

@@ -1,13 +1,14 @@
 [project]
 name = "sqlcompose"
 dynamic = ["version"]
-description = "Composition of linked SQL files"
+description = "Composition of SQL files"
 keywords = ["sql", "composition", "windows", "linux"]
 readme = "README.md"
 authors = [
     { name = "Anders Madsen", email = "anders.madsen@alphavue.com" }
 ]
-license = { text = "MIT" }
+license = "MIT"
+license-files = [ "LICENSE"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Development Status :: 6 - Mature",
@@ -21,13 +22,16 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Software Development :: Libraries",
     "Typing :: Typed"
 ]
-dependencies = []
-requires-python = ">=3.10"
+dependencies = [
+
+]
+requires-python = ">= 3.10, < 3.15"
 
 [project.urls]
 repository = "https://github.com/apmadsen/sqlcompose"
@@ -39,11 +43,12 @@ repository = "https://github.com/apmadsen/sqlcompose"
 test = [
     "pytest>=8.3.0",
     "pytest-cov>=6.1.0",
+    "pytest-mock>=3.15"
 ]
 
-[tool.setuptools.dynamic]
-version = { attr = 'sqlcompose.__init__.__version__' }
+[tool.setuptools-git-versioning]
+enabled = true
 
 [build-system]
-requires = ["setuptools >= 77.0.3"]
-build-backend = "setuptools.build_meta"
+requires = ["setuptools >= 77.0.3", "setuptools-git-versioning >= 2.1.0"]
+build-backend = "setuptools.build_meta"

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/src/sqlcompose/__init__.py

@@ -1,10 +1,10 @@
 from sqlcompose.core.functions import load, loads
 from sqlcompose.core.circular_dependency_error import CircularDependencyError
+from sqlcompose.core.file_not_found_err import FileNotFoundErr
 
 __all__ = [
     'load',
     'loads',
     'CircularDependencyError',
-]
-__package_name__ = "sqlcompose"
-__version__ = "0.0.3"
+    'FileNotFoundErr',
+]

sqlcompose-0.0.4a2/src/sqlcompose/core/app.py

@@ -0,0 +1,30 @@
+from argparse import ArgumentParser
+
+from sqlcompose.core.functions import load, loads
+from sqlcompose.core.compat import is_file, get_piped_input
+from sqlcompose.core.file_not_found_err import FileNotFoundErr
+
+
+def app(args: list[str]) -> tuple[str, int]:
+    try:
+        from sys import stdin # iport must be done here to allow for test patching
+
+        if not stdin.isatty() and ( piped := get_piped_input(stdin) ):
+            sql = loads(piped)
+        else:
+            parser = ArgumentParser(prog = "sqlcompose")
+            parser.add_argument("input", type=str, help = "SQL expression or location of an SQL file")
+            pargs = parser.parse_args(args)
+
+            if is_file(pargs.input):
+                sql = load(pargs.input)
+            else:
+                sql = loads(pargs.input)
+
+        return sql, 0
+    except SystemExit as ex:
+        return str(ex), 2
+    except (FileNotFoundErr, FileNotFoundError) as ex:
+        return str(ex), 3
+    except Exception as ex: # pragma: no cover
+        return f"Unexpected error: {ex}", 1

sqlcompose-0.0.4a2/src/sqlcompose/core/compat.py

@@ -0,0 +1,75 @@
+from os import path, sep
+from typing import TextIO
+from re import compile
+from threading import Thread, Event
+
+RX_FILE = compile(r"^[\w,\s-]+\.[A-Za-z]{3}$")
+WINDOWS_PATH_SEP = "\\"
+UNIX_PATH_SEP = "/"
+
+def fix_path(file_path: str) -> str:
+    """Replaces all path separators, be they Linux or Windows style
+    to the standard path separator of the system.
+
+    Args:
+        file_path (str): The file path to fix.
+    """
+    for str in [ WINDOWS_PATH_SEP, UNIX_PATH_SEP ]:
+        if str != path.sep:
+            file_path = file_path.replace(str, path.sep)
+
+    return file_path
+
+def get_relative_path(file_path: str, root: str) -> str:
+    """Get the path relative to root path.
+
+    Args:
+        file_path (str): The path.
+        root (str): The root path.
+
+    Returns:
+        str: The relative path.
+    """
+    if root == file_path:
+        return file_path
+    else:
+        return path.relpath(file_path, path.commonprefix([root, file_path]))
+
+def is_file(text: str) -> bool:
+    if path.isfile(text):
+        return True
+    elif sep in text and is_file(path.basename(text)):
+        return True
+    elif RX_FILE.match(text):
+        return True
+
+    return False
+
+def get_piped_input(pipe: TextIO) -> str:
+    """Reads input from pipe (usually sys.stdin) without blocking.
+    """
+    output: list[str] = []
+    ev_started = Event()
+    ev_done = Event()
+
+    def fn(output: list[str]):
+        try:
+            ev_started.set()
+            output.append(pipe.read())
+        except OSError:
+            pass
+        finally:
+            ev_done.set()
+
+    thread = Thread(target = fn, args = (output,))
+    thread.start()
+
+    ev_started.wait()
+
+    if ev_done.wait(0.1): # if there is in fact anything in the pipe, we expect it to be read within 0.1 second
+        thread.join()
+    else:
+        pass # pragma: no cover
+        # the thread will block indefinitely, nothing to do about it
+
+    return output[0] if any(output) else ""

sqlcompose-0.0.4a2/src/sqlcompose/core/file_not_found_err.py

@@ -0,0 +1,11 @@
+
+class FileNotFoundErr(Exception):
+    __slots__ = [ "__filename" ]
+
+    def __init__(self, filename: str, error: str | None = None):
+        super().__init__(error or f"File {filename} not found")
+        self.__filename = filename
+
+    @property
+    def filename(self) -> str:
+        return self.__filename # pragma: no cover

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/src/sqlcompose/core/functions.py

@@ -1,11 +1,11 @@
 from os import path
 from typing import Sequence
-from os import path
 from re import compile, sub, escape, IGNORECASE
 from textwrap import indent
 
 from sqlcompose.core.circular_dependency_error import CircularDependencyError
 from sqlcompose.core.include import Include
+from sqlcompose.core.file_not_found_err import FileNotFoundErr
 from sqlcompose.core.compat import fix_path, get_relative_path
 
 REGEX_INCLUDE = compile(r"\$INCLUDE\(([^\)]+)\)", IGNORECASE)
@@ -37,7 +37,7 @@ def load(filename: str) -> str:
     filename = fix_path(filename)
 
     if not path.isfile(filename):
-        raise FileNotFoundError(filename)
+        raise FileNotFoundErr(filename)
 
 
     with open(filename, "r", encoding="utf-8") as file:
@@ -88,11 +88,13 @@ def compose(
                     )
                 )
                 index = index + 1
-            except FileNotFoundError:
+            except (FileNotFoundErr, FileNotFoundError) as ex:
+                filename = get_relative_path(file_path_inner, root)
                 if parent is not None:
-                    raise FileNotFoundError(f"Include failed: File \"{get_relative_path(file_path_inner, root)}\" which was referred to in \"{get_relative_path(parent, root)}\", was not found...")
+                    raise FileNotFoundErr(filename, f"Include failed: File \"{get_relative_path(file_path_inner, root)}\" which was referred to in \"{get_relative_path(parent, root)}\", was not found...") from ex
                 else:
-                    raise FileNotFoundError(f"Include failed: File \"{get_relative_path(file_path_inner, root)}\" was not found...")
+                    raise FileNotFoundErr(filename, f"Include failed: File \"{get_relative_path(file_path_inner, root)}\" was not found...") from ex
+
 
     for include in includes:
         sql = sub(escape(include.match), include.name, sql)

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2/src/sqlcompose.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: sqlcompose
-Version: 0.0.3
-Summary: Composition of linked SQL files
+Version: 0.0.4a2
+Summary: Composition of SQL files
 Author-email: Anders Madsen <anders.madsen@alphavue.com>
-License: MIT
+License-Expression: MIT
 Project-URL: repository, https://github.com/apmadsen/sqlcompose
 Keywords: sql,composition,windows,linux
 Classifier: Development Status :: 5 - Production/Stable
@@ -18,39 +18,54 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
 Requires-Dist: pytest>=8.3.0; extra == "test"
 Requires-Dist: pytest-cov>=6.1.0; extra == "test"
+Requires-Dist: pytest-mock>=3.15; extra == "test"
 Dynamic: license-file
 
 [![Test](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml)
 [![Coverage](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml)
-![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)
+[![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/sqlcompose/releases)
 ![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/sqlcompose?label=pre-release&include_prereleases&sort=semver&color=blue)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlcompose)
+[![PyPI Downloads](https://static.pepy.tech/badge/sqlcompose/week)](https://pepy.tech/projects/sqlcompose)
 
+# sqlcompose: Composition of SQL files
+sqlcompose lets you to compose sql files from multiple files by introducing `$INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
 
-# sqlcompose: Composition of linked SQL files
-sqlcompose allows you to compose sql files from multiple files by introducing `INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
+Using composition, you reduce both complexity and duplication of code thus adhering to the DRY principle.
+
+### SQL Dialect
+sqlcompose outputs SQL as standard ANSI SQL. Note though, that no validation is done on either the input or the output.
 
 ## Examples
-__Execute the script directly:__
-```console
+
+### 1. Execute the script with the filename as an argument and output to the console:
+```bash
 sqlcompose query.sql
 ```
+
+### 2. Pipe data into application and output to a file
+```bash
+cat query.sql | sqlcompose > output.sql
+```
+
+### 3. Execute the script with SQL string as argument
 ```bash
-sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
-sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
+sqlcompose 'select * from $INCLUDE(included-query1.sql)'
 ```
+> NOTE: Different consoles have different limitations, so you may have to switch from single to double quotes to allow for using the dollar sign.
 
-__Import it in another script:__
+### 4. Import it in another python application or package
 ```python
 from sqlcompose import load, loads
 # method 1 : loading from a file

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/src/sqlcompose.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/sqlcompose.egg-info/top_level.txt
 src/sqlcompose/core/app.py
 src/sqlcompose/core/circular_dependency_error.py
 src/sqlcompose/core/compat.py
+src/sqlcompose/core/file_not_found_err.py
 src/sqlcompose/core/functions.py
 src/sqlcompose/core/include.py
 tests/test_app.py

{sqlcompose-0.0.3 → sqlcompose-0.0.4a2}/src/sqlcompose.egg-info/requires.txt

@@ -2,3 +2,4 @@
 [test]
 pytest>=8.3.0
 pytest-cov>=6.1.0
+pytest-mock>=3.15

sqlcompose-0.0.4a2/tests/test_app.py

@@ -0,0 +1,48 @@
+# ruff: noqa
+# pyright: basic
+from os import path, chdir, curdir
+from sys import stdin
+from io import StringIO
+from pytest import fixture, raises as assert_raises
+from pytest_mock import MockerFixture
+
+from sqlcompose.core.app import app
+
+
+def test_missing_args():
+    _result, code = app([])
+    assert code == 2
+
+def test_existing_file_by_path():
+    result, code = app([path.join("tests", "main-query.sql")])
+    assert len(result) > 0
+    assert code == 0
+
+def test_missing_file_by_path():
+    result, code = app([path.join("tests", "nonexisting.sql")])
+    assert len(result) > 0
+    assert code == 3
+
+    result, code = app([f"SELECT * FROM $INCLUDE({path.join('tests', 'nonexisting.sql')})"])
+    assert len(result) > 0
+    assert code == 3
+
+
+def test_sql():
+    result, code = app([f"SELECT * FROM $INCLUDE({path.join('tests', 'main-query.sql')})"])
+    assert len(result) > 0
+    assert code == 0
+
+def test_pipe(mocker: MockerFixture):
+    chdir("tests")
+    try:
+        with open("main-query.sql", "rt", encoding="utf8") as input:
+            mocker.patch(f"sys.stdin", input)
+            try:
+                result, code = app([])
+                assert len(result) > 0
+                assert code == 0
+            finally:
+                mocker.resetall()
+    finally:
+        chdir("..")

sqlcompose-0.0.4a2/tests/test_compat.py

@@ -0,0 +1,48 @@
+# ruff: noqa
+# pyright: basic
+from pytest import fixture, raises as assert_raises
+from sys import platform
+
+from sqlcompose.core.compat import fix_path, get_relative_path
+
+
+def test_fix_path():
+    if platform == "win32":
+        tests = {
+            "sql\\file.sql" : "sql\\file.sql",
+            "sql\\file.sql" : "sql/file.sql",
+        }
+    else:
+        tests = {
+            "sql/file.sql" : "sql\\file.sql",
+            "sql/file.sql" : "sql/file.sql",
+        }
+
+    for expected_result, file_path in tests.items():
+        result = fix_path(file_path)
+        assert result == expected_result
+
+
+def test_get_relative_path():
+    if platform == "win32":
+        tests = {
+            "sql\\file.sql" : ("sql\\file.sql", "sql\\file.sql"),
+            "sql\\file.sql" : ("sql\\file.sql", "c:\\app\\"),
+            "sql\\file.sql" : ("c:\\app\\sql\\file.sql", "c:\\app\\"),
+        }
+
+        p = "sql\\file.sql"
+        assert p == get_relative_path(p, p)
+    else:
+        tests = {
+            "sql/file.sql" : ("sql/file.sql", "sql/file.sql"),
+            "sql/file.sql" : ("sql/file.sql", "/app/"),
+            "sql/file.sql" : ("/app/sql/file.sql", "/app/"),
+        }
+        p = "sql/file.sql"
+        assert p == get_relative_path(p, p)
+
+    for expected_result, (file_path, root) in tests.items():
+        result = get_relative_path(file_path, root)
+        assert result == expected_result
+

sqlcompose-0.0.4a2/tests/test_functions.py

@@ -0,0 +1,42 @@
+# ruff: noqa
+# pyright: basic
+from pytest import fixture, raises as assert_raises
+
+from sqlcompose import loads, load, CircularDependencyError, FileNotFoundErr
+from sqlcompose.core.functions import compose
+
+
+def test_nonexisting():
+    with assert_raises(FileNotFoundErr):
+        load("nonexisting.sql")
+    with assert_raises(FileNotFoundErr):
+        load("tests/non_existing_include.sql")
+    with assert_raises(FileNotFoundErr):
+        compose("select * from $INCLUDE(some_file_that_does_not_exist.sql)", "SQL", ".", ".")
+
+
+    filename = "tests/existing_include.sql"
+    with open(filename, "r", encoding="utf-8") as file:
+        with assert_raises(FileNotFoundErr):
+            compose(file.read(), filename, filename, ".")
+
+def test_reuse_composition():
+    result = compose("select * from $INCLUDE(tests/includes/included-query3.sql)", "SQL", ".", ".")
+    # print(result)
+    assert len(result) > 0
+
+
+def test_existing_file_by_path():
+    result = load("tests/main-query.sql")
+    # print(result)
+    assert len(result) > 0
+
+def test_sql():
+    result = loads("SELECT * FROM $INCLUDE(tests/main-query.sql)")
+    # print(result)
+    assert len(result) > 0
+
+def test_circular_dependency():
+    with assert_raises(CircularDependencyError):
+        load("tests/circular_left.sql")
+

sqlcompose-0.0.3/src/sqlcompose/core/app.py

@@ -1,22 +0,0 @@
-from os import path
-from argparse import ArgumentParser
-
-from sqlcompose.core.functions import load, loads
-
-
-def app(args: list[str]) -> tuple[str, int ]:
-    try:
-        parser = ArgumentParser(prog = "sqlcompose")
-        parser.add_argument("input", type=str, help = "SQL expression or location of an SQL file")
-        pargs = parser.parse_args(args)
-
-        if path.isfile(pargs.input):
-            sql = load(pargs.input)
-        else:
-            sql = loads(pargs.input)
-
-        return sql, 0
-    except SystemExit as ex:
-        return str(ex), 2
-    except Exception as ex: # pragma: no cover
-        return f"Unexpected error: {ex}", 1

sqlcompose-0.0.3/src/sqlcompose/core/compat.py

@@ -1,32 +0,0 @@
-from os import path
-
-WINDOWS_PATH_SEP = "\\"
-UNIX_PATH_SEP = "/"
-
-def fix_path(file_path: str) -> str:
-    """Replaces all path separators, be they Linux or Windows style
-    to the standard path separator of the system.
-
-    Args:
-        file_path (str): The file path to fix.
-    """
-    for str in [ WINDOWS_PATH_SEP, UNIX_PATH_SEP ]:
-        if str != path.sep:
-            file_path = file_path.replace(str, path.sep)
-
-    return file_path
-
-def get_relative_path(file_path: str, root: str) -> str:
-    """Get the path relative to root path.
-
-    Args:
-        file_path (str): The path.
-        root (str): The root path.
-
-    Returns:
-        str: The relative path.
-    """
-    if root == file_path:
-        return file_path
-    else:
-        return path.relpath(file_path, path.commonprefix([root, file_path]))

sqlcompose-0.0.3/tests/test_app.py

@@ -1,29 +0,0 @@
-# pyright: basic
-from unittest import TestCase, main
-
-from sqlcompose.core.app import app
-
-class Test(TestCase):
-    # def test_nonexisting(self):
-    #     _result, code = app(["nonexisting.sql"])
-    #     self.assertEqual(code, 1)
-
-    def test_missing_args(self):
-        _result, code = app([])
-        self.assertEqual(code, 2)
-
-    def test_existing_file_by_path(self):
-        result, code = app(["tests/main-query.sql"])
-        self.assertGreater(len(result), 0)
-        self.assertEqual(code, 0)
-
-    def test_sql(self):
-        result, code = app(["SELECT * FROM $INCLUDE(tests/main-query.sql)"])
-        # print(result)
-        self.assertGreater(len(result), 0)
-        self.assertEqual(code, 0)
-
-
-if __name__ == '__main__':
-    main()
-

sqlcompose-0.0.3/tests/test_compat.py

@@ -1,52 +0,0 @@
-# pyright: basic
-from unittest import TestCase, main
-from sys import platform
-
-from sqlcompose.core.compat import fix_path, get_relative_path
-
-class Test(TestCase):
-
-    def test_fix_path(self):
-        if platform == "win32":
-            tests = {
-                "sql\\file.sql" : "sql\\file.sql",
-                "sql\\file.sql" : "sql/file.sql",
-            }
-        else:
-            tests = {
-                "sql/file.sql" : "sql\\file.sql",
-                "sql/file.sql" : "sql/file.sql",
-            }
-
-        for expected_result, file_path in tests.items():
-            result = fix_path(file_path)
-            self.assertEqual(result, expected_result)
-
-
-    def test_get_relative_path(self):
-        if platform == "win32":
-            tests = {
-                "sql\\file.sql" : ("sql\\file.sql", "sql\\file.sql"),
-                "sql\\file.sql" : ("sql\\file.sql", "c:\\app\\"),
-                "sql\\file.sql" : ("c:\\app\\sql\\file.sql", "c:\\app\\"),
-            }
-
-            p = "sql\\file.sql"
-            self.assertEqual(p, get_relative_path(p, p))
-        else:
-            tests = {
-                "sql/file.sql" : ("sql/file.sql", "sql/file.sql"),
-                "sql/file.sql" : ("sql/file.sql", "/app/"),
-                "sql/file.sql" : ("/app/sql/file.sql", "/app/"),
-            }
-            p = "sql/file.sql"
-            self.assertEqual(p, get_relative_path(p, p))
-
-        for expected_result, (file_path, root) in tests.items():
-            result = get_relative_path(file_path, root)
-            self.assertEqual(result, expected_result)
-
-
-if __name__ == '__main__':
-    main()
-

sqlcompose-0.0.3/tests/test_functions.py

@@ -1,40 +0,0 @@
-# pyright: basic
-from unittest import TestCase, main
-
-from sqlcompose import loads, load, CircularDependencyError
-from sqlcompose.core.functions import compose
-
-class Test(TestCase):
-    def test_nonexisting(self):
-        self.assertRaises(FileNotFoundError, load, "nonexisting.sql")
-        self.assertRaises(FileNotFoundError, load, "tests/non_existing_include.sql")
-        self.assertRaises(FileNotFoundError, compose, "select * from $INCLUDE(some_file_that_does_not_exist.sql)", "SQL", ".", ".")
-
-        filename = "tests/existing_include.sql"
-        with open(filename, "r", encoding="utf-8") as file:
-            self.assertRaises(FileNotFoundError, compose, file.read(), filename, filename, ".")
-
-    def test_reuse_composition(self):
-        result = compose("select * from $INCLUDE(tests/includes/included-query3.sql)", "SQL", ".", ".")
-        # print(result)
-        self.assertTrue(len(result) > 0)
-
-
-    def test_existing_file_by_path(self):
-        result = load("tests/main-query.sql")
-        # print(result)
-        self.assertTrue(len(result) > 0)
-
-    def test_sql(self):
-        result = loads("SELECT * FROM $INCLUDE(tests/main-query.sql)")
-        # print(result)
-        self.assertTrue(len(result) > 0)
-
-    def test_circular_dependency(self):
-        self.assertRaises(CircularDependencyError, load, "tests/circular_left.sql")
-
-
-
-if __name__ == '__main__':
-    main()
-