mercuto-client 0.1.0__py3-none-any.whl

mercuto_client/__init__.py

@@ -0,0 +1,30 @@
+"""
+Copyright (C) 2025 Rockfield Technologies Australia Pty Ltd
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+from typing import Mapping, Optional
+
+from .client import MercutoClient
+from .exceptions import MercutoClientException, MercutoHTTPException
+
+__all__ = ['MercutoClient', 'MercutoHTTPException', 'MercutoClientException']
+
+
+def connect(api_key: Optional[str] = None,
+            service_token: Optional[str] = None,
+            headers: Optional[Mapping[str, str]] = None) -> MercutoClient:
+    return MercutoClient().connect(api_key=api_key,
+                                   service_token=service_token,
+                                   headers=headers)

mercuto_client/_tests/test_ingester/test_file_processor.py

@@ -0,0 +1,210 @@
+import os
+import sqlite3
+import tempfile
+import time
+from typing import Generator, Tuple
+
+import pytest
+
+from ...ingester.processor import FileProcessor
+
+
+def mock_process_callback(filepath: str) -> bool:
+    return "success" in filepath  # Simulate success if filename contains "success"
+
+
+@pytest.fixture
+def temp_env() -> Generator[Tuple[FileProcessor, str, str], None, None]:
+    """Setup temporary directory and database"""
+    buffer_dir: str = tempfile.mkdtemp()
+    workdir = tempfile.mkdtemp()
+    db_path: str = os.path.join(workdir, "test_buffer.db")
+
+    processor: FileProcessor = FileProcessor(
+        buffer_dir=buffer_dir,
+        db_path=db_path,
+        max_files=3,
+        max_attempts=2,
+        process_callback=mock_process_callback
+    )
+
+    yield processor, buffer_dir, db_path
+
+    # Cleanup
+    if os.path.exists(db_path):
+        os.remove(db_path)
+
+
+def test_init_db(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Verify database initialization"""
+    processor, _, db_path = temp_env
+    conn: sqlite3.Connection = sqlite3.connect(db_path)
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='file_buffer'")
+    assert cursor.fetchone() is not None  # Table should exist
+    conn.close()
+
+
+def test_register_file(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Check if new files are correctly registered in the database"""
+    processor, buffer_dir, _ = temp_env
+    test_file: str = os.path.join(buffer_dir, "file1.txt")
+
+    # Create a test file
+    with open(test_file, "w") as f:
+        f.write("Test content")
+
+    processor.add_file_to_db(test_file)
+
+    conn: sqlite3.Connection = sqlite3.connect(processor.get_db_path())
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT filename FROM file_buffer WHERE filename = 'file1.txt'")
+    assert cursor.fetchone() is not None  # File should be registered
+    conn.close()
+
+
+def test_file_processing(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Verify file processing and persistence"""
+    processor, buffer_dir, _ = temp_env
+    test_file: str = os.path.join(buffer_dir, "success_file.txt")
+
+    with open(test_file, "w") as f:
+        f.write("Test content")
+
+    processor.add_file_to_db(test_file)
+    processor.process_next_file()
+
+    conn: sqlite3.Connection = sqlite3.connect(processor.get_db_path())
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT status FROM file_buffer WHERE filename = 'success_file.txt'")
+    # File should be marked as processed
+    assert cursor.fetchone()[0] == "processed"
+    conn.close()
+
+
+def test_file_processing_in_order(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Verify file processing and persistence"""
+    processor, buffer_dir, _ = temp_env
+
+    # Make some test files but with a reverse name so the order on the filesystem is not the same as the order in the database
+    for i in reversed(range(5)):
+        test_file: str = os.path.join(buffer_dir, f"success_file_{i}.txt")
+        with open(test_file, "w") as f:
+            f.write("Test content")
+
+        processor.add_file_to_db(test_file)
+
+    for i in reversed(range(5)):
+        processed = processor.process_next_file()
+        assert processed is not None, "Should process a file"
+        name = os.path.basename(processed)
+        assert name == f'success_file_{i}.txt', f"Should process files in order, got {name}"
+
+
+def test_retry_attempts(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Ensure failed files are retried up to max_attempts"""
+    processor, buffer_dir, _ = temp_env
+    test_file: str = os.path.join(buffer_dir, "fail_file.txt")
+
+    with open(test_file, "w") as f:
+        f.write("Test content")
+
+    processor.add_file_to_db(test_file)
+
+    for _ in range(2):
+        processor.process_next_file()
+
+    conn: sqlite3.Connection = sqlite3.connect(processor.get_db_path())
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT attempts FROM file_buffer WHERE filename = 'fail_file.txt'")
+    # Should match max_attempts
+    assert cursor.fetchone()[0] == 2
+    conn.close()
+
+
+@pytest.mark.parametrize("filename_part", ["success", "unprocessed", "failed"])
+def test_cleanup_old_files_different_processing_status(temp_env: Tuple[FileProcessor, str, str], filename_part: str) -> None:
+    """Ensure cleanup keeps only max_files, no matter the file status"""
+    processor, buffer_dir, _ = temp_env
+
+    # Create more files than max_files limit
+    for i in range(5):
+        test_file: str = os.path.join(buffer_dir, f"{filename_part}{i}.txt")
+        with open(test_file, "w") as f:
+            f.write("Test content")
+        processor.add_file_to_db(test_file)
+        if filename_part != 'unprocessed':
+            # Process files that are not unprocessed
+            processor.process_next_file()
+
+    processor.cleanup_old_files()
+
+    conn: sqlite3.Connection = sqlite3.connect(processor.get_db_path())
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT COUNT(*) FROM file_buffer")
+    # Should retain only max_files
+    assert cursor.fetchone()[0] == 3
+
+    # The last fiiles should be index 2,3,4
+    cursor.execute(
+        "SELECT filename FROM file_buffer ORDER BY timestamp ASC")
+    remaining_files: list[tuple[str]] = cursor.fetchall()
+    expected_files = [f"{filename_part}2.txt", f"{filename_part}3.txt", f"{filename_part}4.txt"]
+    assert [f[0] for f in remaining_files] == expected_files
+
+    conn.close()
+
+
+def test_scan_existing_files(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Ensure that new files added are detected"""
+    processor, buffer_dir, _ = temp_env
+
+    for i in range(5):
+        test_file = os.path.join(buffer_dir, f"file{i}.txt")
+        with open(test_file, "w") as f:
+            f.write("Test content")
+        time.sleep(0.05)
+
+    processor.scan_existing_files()
+    conn: sqlite3.Connection = sqlite3.connect(processor.get_db_path())
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT filename FROM file_buffer ORDER BY timestamp asc")
+
+    files: list[tuple[str]] = cursor.fetchall()
+    conn.close()
+    assert files == [('file0.txt',), ('file1.txt',), ('file2.txt',), ('file3.txt',), ('file4.txt',)]
+
+
+def test_scan_existing_files_that_havnt_been_processed(temp_env: Tuple[FileProcessor, str, str]) -> None:
+    """Ensure that new files added are detected"""
+    processor, buffer_dir, _ = temp_env
+
+    for i in range(5):
+        test_file = os.path.join(buffer_dir, f"file{i}.txt")
+        with open(test_file, "w") as f:
+            f.write("Test content")
+        time.sleep(0.05)
+
+        if i < 3:
+            # Simulate adding for the first 3 files
+            processor.add_file_to_db(test_file)
+        if i < 2:
+            # Simulate processing for the first 2 files
+            processor.process_next_file()
+
+    time.sleep(0.05)
+    processor.scan_existing_files()
+    conn: sqlite3.Connection = sqlite3.connect(processor.get_db_path())
+    cursor: sqlite3.Cursor = conn.cursor()
+    cursor.execute(
+        "SELECT filename FROM file_buffer ORDER BY timestamp asc")
+
+    files: list[tuple[str]] = cursor.fetchall()
+    conn.close()
+    assert files == [('file0.txt',), ('file1.txt',), ('file2.txt',), ('file3.txt',), ('file4.txt',)]

mercuto_client/_tests/test_ingester/test_ftp.py

@@ -0,0 +1,37 @@
+import ftplib
+import io
+import os
+import tempfile
+from datetime import datetime, timezone
+
+from ...ingester.ftp import simple_ftp_server
+
+
+def test_simple_ftp_server():
+    receives = []
+    def clock(): return datetime(2023, 10, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        with simple_ftp_server(directory=temp_dir,
+                               username='test', password='password', port=2121,
+                               callback=lambda dest: receives.append(dest), clock=clock):
+            client = ftplib.FTP()
+            client.connect('localhost', 2121)
+            client.login('test', 'password')
+
+            # Upload a test file
+            testbuf = io.BytesIO(b'This is a test file.')
+            client.storbinary('STOR test_file.txt', testbuf)
+
+        assert len(receives) == 1
+        assert receives[0].endswith('test_file_20231001T120000.txt')
+
+        # Verify the file was uploaded correctly
+        with open(receives[0], 'rb') as f:
+            content = f.read()
+            assert content == b'This is a test file.'
+
+        # Ensure that the file exists in the temp directory
+        found = os.listdir(temp_dir)
+        assert 'test_file_20231001T120000.txt' in found
+        assert len(found) == 1  # Only one file should be present

mercuto_client/_tests/test_ingester/test_parsers.py

@@ -0,0 +1,145 @@
+import math
+import os
+import tempfile
+
+import pytest
+
+from ...ingester.parsers import (detect_parser, parse_campbell_file,
+                                 parse_worldsensing_compact_file,
+                                 parse_worldsensing_standard_file)
+
+RESOURCES_DIR = os.path.join(os.path.dirname(__file__), "resources")
+
+
+def test_worldsensing_compacted_parser():
+    file = os.path.join(RESOURCES_DIR, "worldsensing-compacted-sample-file.dat")
+    mapper = {
+        "channel1": "12345678",
+        "channel2": "abcdefgh",
+    }
+    samples = parse_worldsensing_compact_file(file, mapper)
+    assert len(samples) == 4
+    assert samples[0]['channel_code'] == "12345678"
+    assert math.isclose(samples[0]['value'], -10)
+    assert samples[0]['timestamp'] == '2025-05-20T15:00:00'
+
+    assert samples[1]['channel_code'] == "abcdefgh"
+    assert math.isclose(samples[1]['value'], 5)
+    assert samples[0]['timestamp'] == '2025-05-20T15:00:00'
+
+    assert samples[2]['channel_code'] == "12345678"
+    assert math.isclose(samples[2]['value'], -12)
+    assert samples[2]['timestamp'] == '2025-05-20T16:00:00'
+
+    assert samples[3]['channel_code'] == "abcdefgh"
+    assert math.isclose(samples[3]['value'], 10)
+    assert samples[3]['timestamp'] == '2025-05-20T16:00:00'
+
+
+def test_worldsensing_standard_parser():
+    file = os.path.join(RESOURCES_DIR, "worldsensing-standard-sample-file.csv")
+    mapper = {
+        "AtmPressure-85544-in-mbar": "12345678",
+        "freqSqInDigit-85544-VW-Ch1": "abcdefgh",
+    }
+    samples = parse_worldsensing_standard_file(file, mapper)
+    assert len(samples) == 10
+    assert samples[0]['channel_code'] == "12345678"
+    assert math.isclose(samples[0]['value'], 930.5)
+    assert samples[0]['timestamp'] == '2024-04-15T12:35:00'
+
+    assert samples[1]['channel_code'] == "abcdefgh"
+    assert math.isclose(samples[1]['value'], 726.810811024)
+    assert samples[1]['timestamp'] == '2024-04-15T12:35:00'
+
+    assert samples[8]['channel_code'] == "12345678"
+    assert math.isclose(samples[8]['value'], 930.4)
+    assert samples[8]['timestamp'] == '2024-04-15T12:39:00'
+
+    assert samples[9]['channel_code'] == "abcdefgh"
+    assert math.isclose(samples[9]['value'], 726.841502500)
+    assert samples[9]['timestamp'] == '2024-04-15T12:39:00'
+
+
+def test_campbells_parser():
+    file = os.path.join(RESOURCES_DIR, "campbell-sample-file.dat")
+    mapper = {
+        "VWu_1": "aaaaaaaa",
+        "VWu_2": "bbbbbbbb",
+        "Therm(1)": "cccccccc",
+        "Therm(2)": "dddddddd",
+        "Diag_Max(1)": "eeeeeeee",
+        "Diag_Max(2)": "ffffffff",
+    }
+    samples = parse_campbell_file(file, mapper)
+    assert len(samples) == 6*4
+
+    assert samples[0]['channel_code'] == "aaaaaaaa"
+    assert math.isclose(samples[0]['value'], 1234.5)
+    assert samples[0]['timestamp'] == '2023-12-07T00:01:00'
+
+    for i in range(1, 6):
+        assert samples[i]['channel_code'] == list(mapper.values())[i]
+        assert math.isnan(samples[i]['value'])
+        assert samples[i]['timestamp'] == '2023-12-07T00:01:00'
+
+    assert samples[6]['channel_code'] == "aaaaaaaa"
+    assert math.isclose(samples[6]['value'], 1234.5)
+    assert samples[6]['timestamp'] == '2023-12-07T00:02:00'
+    for i in range(7, 12):
+        assert samples[i]['channel_code'] == list(mapper.values())[i-6]
+        assert math.isnan(samples[i]['value'])
+        assert samples[i]['timestamp'] == '2023-12-07T00:02:00'
+
+    assert samples[12]['channel_code'] == "aaaaaaaa"
+    assert math.isclose(samples[12]['value'], 1234.5)
+    assert samples[12]['timestamp'] == '2023-12-07T00:03:00'
+    assert samples[13]['channel_code'] == "bbbbbbbb"
+    assert math.isclose(samples[13]['value'], 1234.5)
+    assert samples[13]['timestamp'] == '2023-12-07T00:03:00'
+
+    for i in range(15, 17):
+        assert samples[i]['channel_code'] == list(mapper.values())[i-12]
+        assert math.isnan(samples[i]['value'])
+        assert samples[i]['timestamp'] == '2023-12-07T00:03:00'
+    assert samples[17]['channel_code'] == "ffffffff"
+    assert math.isclose(samples[17]['value'], 1537)
+    assert samples[17]['timestamp'] == '2023-12-07T00:03:00'
+
+    assert samples[18]['channel_code'] == "aaaaaaaa"
+    assert math.isclose(samples[18]['value'], 1234.5)
+    assert samples[18]['timestamp'] == '2023-12-07T00:04:00'
+    assert samples[19]['channel_code'] == "bbbbbbbb"
+    assert math.isclose(samples[19]['value'], 1234.5)
+    assert samples[19]['timestamp'] == '2023-12-07T00:04:00'
+    assert samples[20]['channel_code'] == "cccccccc"
+    assert math.isclose(samples[20]['value'], 27.5)
+    assert samples[20]['timestamp'] == '2023-12-07T00:04:00'
+    assert samples[21]['channel_code'] == "dddddddd"
+    assert math.isclose(samples[21]['value'], 25)
+    assert samples[21]['timestamp'] == '2023-12-07T00:04:00'
+    assert samples[22]['channel_code'] == "eeeeeeee"
+    assert math.isclose(samples[22]['value'], 255)
+    assert samples[22]['timestamp'] == '2023-12-07T00:04:00'
+    assert samples[23]['channel_code'] == "ffffffff"
+    assert math.isclose(samples[23]['value'], 0)
+    assert samples[23]['timestamp'] == '2023-12-07T00:04:00'
+
+
+def test_detect_file_type():
+    compacted_file = os.path.join(RESOURCES_DIR, "worldsensing-compacted-sample-file.dat")
+    standard_file = os.path.join(RESOURCES_DIR, "worldsensing-standard-sample-file.csv")
+    campbell_file = os.path.join(RESOURCES_DIR, "campbell-sample-file.dat")
+
+    assert detect_parser(compacted_file) == parse_worldsensing_compact_file
+    assert detect_parser(standard_file) == parse_worldsensing_standard_file
+    assert detect_parser(campbell_file) == parse_campbell_file
+
+    # Test with an unknown file type
+    with tempfile.TemporaryDirectory() as dir:
+        unknown_file = os.path.join(dir, "unknown-file.txt")
+        with open(unknown_file, "w") as f:
+            f.write("This is an unknown file format.")
+
+        with pytest.raises(ValueError):
+            detect_parser(unknown_file)

mercuto_client/_tests/test_mocking.py

@@ -0,0 +1,93 @@
+import pytest
+
+from .. import MercutoClient
+from ..mocks import mock_client
+
+
+def test_mock_injection_before_client_creation():
+    count = 0
+
+    def on_get_healthcheck(*args, **kwargs):
+        nonlocal count
+        count += 1
+        return 'mocked'
+    with mock_client() as mock:
+        mock.on('GET', '/healthcheck', on_get_healthcheck)
+        client = MercutoClient()
+        assert client.healthcheck() == 'mocked'
+    assert count == 1
+
+
+def test_mock_injection_after_client_creation():
+    count = 0
+    client = MercutoClient()
+
+    def on_get_healthcheck(*args, **kwargs):
+        nonlocal count
+        count += 1
+        return 'mocked'
+    with mock_client() as mock:
+        mock.on('GET', '/healthcheck', on_get_healthcheck)
+        assert client.healthcheck() == 'mocked'
+    assert count == 1
+
+
+def test_mock_releases_after_end_of_context():
+    client = MercutoClient()
+    with mock_client() as mock:
+        key = mock.add_user(user='this is a test')
+        client.connect(api_key=key)
+        assert client.identity().verify_me()['user'] == 'this is a test'
+
+    with pytest.raises(Exception):
+        client.identity().verify_me()
+
+
+def test_mock_verify_me():
+    client = MercutoClient()
+    with mock_client() as mock:
+        with pytest.raises(Exception):
+            client.identity().verify_me()
+
+        client.connect(api_key='bad api key')
+        with pytest.raises(Exception):
+            client.identity().verify_me()
+
+        key = mock.add_user(user='this is a test user',
+                            tenant='test-tenant', permission_group='test-group')
+        client.connect(api_key=key)
+        assert client.identity().verify_me()['user'] == 'this is a test user'
+        assert client.identity().verify_me()['tenant'] == 'test-tenant'
+        assert client.identity().verify_me()[
+            'permission_group'] == 'test-group'
+
+        mock.delete_user(key)
+        with pytest.raises(Exception):
+            client.identity().verify_me()
+
+
+def test_mock_get_user():
+    client = MercutoClient()
+    with mock_client() as mock:
+        client.connect(api_key='bad api key')
+        with pytest.raises(Exception):
+            client.identity().get_user('12345')
+
+        key = mock.add_user(user='code1', tenant='test-tenant', permission_group='test-group',
+                            username='testing@example.com')
+        client.connect(api_key=key)
+
+        assert client.identity().get_user('code1')['code'] == 'code1'
+        assert client.identity().get_user(
+            'code1')['username'] == 'testing@example.com'
+
+        mock.delete_user(key)
+        with pytest.raises(Exception):
+            client.identity().verify_me()
+
+
+def test_mock_unsupported_endpoint():
+    client = MercutoClient()
+    with mock_client():
+        with pytest.raises(NotImplementedError):
+            client.identity().list_tenants()

mercuto_client/_util.py

@@ -0,0 +1,13 @@
+from datetime import timedelta
+
+
+def timedelta_isoformat(td: timedelta) -> str:
+    """
+    ISO 8601 encoding for Python timedelta object.
+    Taken from pydantic source:
+        https://github.com/pydantic/pydantic/blob/3704eccce4661455acdda1cdcf716bd4b3382e08/pydantic/deprecated/json.py#L135-L140
+
+    """
+    minutes, seconds = divmod(td.seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    return f'{"-" if td.days < 0 else ""}P{abs(td.days)}DT{hours:d}H{minutes:d}M{seconds:d}.{td.microseconds:06d}S'

mercuto_client/acl.py

@@ -0,0 +1,101 @@
+import json
+from typing import TypeVar
+
+from .types import AccessControlListJson, AccessControlListJsonEntry
+
+
+class ResourceTypes:
+    WILDCARD = '*'
+
+    class Mercuto:
+        """
+        Resource types available for ServiceTypes.MERCUTO
+        """
+        PROJECT = 'project'
+        SYSTEM = 'system'
+        WILDCARD = '*'
+
+    class Identity:
+        """
+        Resource types available for ServiceTypes.IDENTITY
+        """
+        TENANT = 'tenant'
+        WILDCARD = '*'
+
+
+class AllowedActions:
+    WILDCARD = '*'
+
+    class Mercuto:
+        """
+        Actions available for ServiceTypes.MERCUTO
+        """
+        WILDCARD = '*'
+        VIEW_PROJECT = 'MERCUTO:VIEW_PROJECT'
+        MANAGE_PROJECT = 'MERCUTO:MANAGE_PROJECT'
+        EDIT_PROJECT = 'MERCUTO:EDIT_PROJECT'
+        UPLOAD_DATA = 'MERCUTO:UPLOAD_DATA'
+        EDIT_SYSTEM = 'MERCUTO:EDIT_SYSTEM'
+
+    class Identity:
+        """
+        Actions available for ServiceTypes.IDENTITY
+        """
+        WILDCARD = '*'
+        VIEW_TENANT = 'IDENTITY:VIEW_TENANT'
+        MANAGE_TENANT = 'IDENTITY:MANAGE_TENANT'
+        EDIT_TENANT = 'IDENTITY:EDIT_TENANT'
+        VIEW_USER_DETAILED_INFO = 'IDENTITY:VIEW_USER_DETAILED_INFO'
+        CREATE_NEW_TENANTS = 'IDENTITY:CREATE_NEW_TENANTS'
+
+
+class ServiceTypes:
+    class Mercuto:
+        Name = 'mercuto'
+        ResourceTypes = ResourceTypes.Mercuto
+        AllowedActions = AllowedActions.Mercuto
+
+    class Identity:
+        Name = 'identity'
+        ResourceTypes = ResourceTypes.Identity
+        AllowedActions = AllowedActions.Identity
+
+    IDENTITY = Identity.Name
+    MERCUTO = Mercuto.Name
+    WILDCARD = '*'
+
+
+T = TypeVar('T', bound='AclPolicyBuilder')
+
+
+class AclPolicyBuilder:
+    def __init__(self) -> None:
+        self._permissions: list[AccessControlListJsonEntry] = []
+
+    def allow(self: T, action: str, resource: str) -> T:
+        self._permissions.append({
+            'action': action,
+            'resource': resource
+        })
+        return self
+
+    def allow_all(self: T, action: str) -> T:
+        self.allow(action, f"mrn:{ServiceTypes.WILDCARD}:{ResourceTypes.WILDCARD}/{ResourceTypes.WILDCARD}")
+        return self
+
+    def allow_project(self: T, action: str, project_code: str) -> T:
+        self.allow(action, f"mrn:{ServiceTypes.MERCUTO}:{ResourceTypes.Mercuto.PROJECT}/{project_code}")
+        return self
+
+    def allow_tenant(self: T, action: str, tenant_code: str) -> T:
+        self.allow(action, f"mrn:{ServiceTypes.IDENTITY}:{ResourceTypes.Identity.TENANT}/{tenant_code}")
+        return self
+
+    def as_string(self) -> str:
+        return json.dumps(self.as_dict())
+
+    def as_dict(self) -> AccessControlListJson:
+        return {
+            'version': 1,
+            'permissions': self._permissions
+        }