robotframework-rpycremote 0.0.1__tar.gz

robotframework_rpycremote-0.0.1/.github/workflows/pipeline.yml

@@ -0,0 +1,90 @@
+name: Pipeline Tests
+
+on:
+  push:
+    branches: [ 'main' ]
+  pull_request:
+    branches: [ 'main' ]
+  schedule:
+    - cron: 0 0 * * *
+
+permissions:
+  contents: read
+
+jobs:
+  flake8:
+    strategy:
+      matrix:
+        os: [ 'ubuntu-latest' ]
+        python-version: [ '3.8', '3.9', '3.10', '3.11' ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U flake8 flake8-polyfill robotframework
+      - name: Analysing the code with flake8
+        run: |
+          flake8 $(git ls-files '*.py') --count --show-source --max-complexity=11 --statistics
+
+  pylint:
+    strategy:
+      matrix:
+        os: [ 'ubuntu-latest' ]
+        python-version: [ '3.8', '3.9', '3.10', '3.11' ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U setuptools_scm setuptools pylint robotframework pyyaml rpyc
+      - name: Analysing the code with pylint
+        run: |
+          pylint --module-naming-style=any $(git ls-files '*.py')
+
+  robot-framework:
+    strategy:
+      matrix:
+        os: [ 'ubuntu-latest', 'windows-latest' ]
+        python-version: [ '3.8', '3.9', '3.10', '3.11' ]
+        robotframework-version: [ '5.0.1', '6.0.2', '6.1', '7.0', 'latest' ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Upgrade pip
+        run: |
+          python -m pip install --upgrade pip
+          pip install -U setuptools_scm setuptools
+      - name: Install PyYaml
+        run: |
+          pip install pyyaml
+      - name: Install robotframework latest
+        if: ${{ matrix.robotframework-version == 'latest' }}
+        run: |
+          pip install -U robotframework
+      - name: Install robotframework ${{ matrix.robotframework-version }}
+        if: ${{ matrix.robotframework-version != 'latest' }}
+        run: |
+          pip install robotframework==${{ matrix.robotframework-version }}
+      - name: Install RPyCRobotRemote
+        run: |
+          pip install -e .
+      - name: Executing Robot Framework Tests
+        run: |
+          python test/server.py 2>&1 &
+          sleep 3
+          robot test/ 2>&1

robotframework_rpycremote-0.0.1/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -U build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: ${{ secrets.PYPI_API_USERNAME }}
+        password: ${{ secrets.PYPI_API_PASSWORD }}

robotframework_rpycremote-0.0.1/.gitignore

@@ -0,0 +1,12 @@
+/RPyCRobotRemote/_version.py
+/venv*/
+/allowed_signers
+\#*\#
+*~
+*.pyc
+*.egg-info/
+log.html
+output.xml
+report.html
+syslog.txt
+debug.txt

robotframework_rpycremote-0.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 René Lehfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotframework_rpycremote-0.0.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.1
+Name: robotframework-rpycremote
+Version: 0.0.1
+Summary: Robot Framework Remote Library based on RPyC
+Author-email: René Lehfeld <54720674+rlehfeld@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rlehfeld/robotframework-rpycremote
+Project-URL: Bug Reports, https://github.com/rlehfeld/robotframework-rpycremote/issues
+Project-URL: Source, https://github.com/rlehfeld/robotframework-rpycremote/
+Keywords: robotframework,robot-framework,rpyc
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: robotframework>=5.0.1
+Requires-Dist: rpyc>=6.0.0
+
+RPyC Robot Remote Library
+============================
+Generic Robot Framework Remote library based on RPyC
+
+Installation
+============
+Install the latest release via PyPi using pip:
+
+::
+
+    pip install robotframework-rpycremote
+
+Or add to your ``conda.yaml`` file:
+
+::
+
+    - pip:
+        - robotframework-rpycremote
+
+
+In oder to help with development you can directly install from GitHub via:
+
+::
+
+    pip install git+https://github.com/rlehfeld/robotframework-rpycremote.git
+
+Or add to your ``conda.yaml`` file:
+
+::
+
+    - pip:
+        - git+https://github.com/rlehfeld/robotframework-rpycremote.git
+
+
+Usage
+=====

robotframework_rpycremote-0.0.1/README.rst

@@ -0,0 +1,36 @@
+RPyC Robot Remote Library
+============================
+Generic Robot Framework Remote library based on RPyC
+
+Installation
+============
+Install the latest release via PyPi using pip:
+
+::
+
+    pip install robotframework-rpycremote
+
+Or add to your ``conda.yaml`` file:
+
+::
+
+    - pip:
+        - robotframework-rpycremote
+
+
+In oder to help with development you can directly install from GitHub via:
+
+::
+
+    pip install git+https://github.com/rlehfeld/robotframework-rpycremote.git
+
+Or add to your ``conda.yaml`` file:
+
+::
+
+    - pip:
+        - git+https://github.com/rlehfeld/robotframework-rpycremote.git
+
+
+Usage
+=====

robotframework_rpycremote-0.0.1/RPyCRobotRemote/RPyCRobotRemoteClient.py

@@ -0,0 +1,165 @@
+"""
+Client Implementation for RPyCRobotRemote
+"""
+import sys
+import functools
+import logging
+from typing import Callable
+from contextlib import contextmanager
+import rpyc
+from robot.libraries.DateTime import convert_time
+from robot.api.deco import not_keyword
+
+
+@contextmanager
+def redirect(conn):
+    """
+    Redirects the other party's ``stdout`` and ``stderr`` to local
+    """
+    # pylint: disable=W0212
+    alreadyredirected, conn._is_redirected = conn._is_redirected, True
+    if not alreadyredirected and conn._is_connected:
+        # pylint: enable=W0212
+        orig_stdout = conn.root.stdout
+        orig_stderr = conn.root.stderr
+
+        try:
+            conn.root.stdout = sys.stdout
+            conn.root.stderr = sys.stderr
+            yield
+        finally:
+            try:
+                conn.root.stdout = orig_stdout
+                conn.root.stderr = orig_stderr
+            except EOFError:
+                pass
+            # pylint: disable=W0212
+            conn._is_redirected = False
+            # pylint: enable=W0212
+    else:
+        yield
+
+
+def redirect_output(func: Callable):
+    """
+    decorator for RPyC connetion to automatically forward
+    stdout and stderr from remote to local
+    """
+    this = getattr(func, '__self__', None)
+    function = getattr(func, '__func__', func)
+
+    @functools.wraps(function)
+    def sync_request(self, handler, *args, **kwargs):
+        with redirect(self):
+            return function(self, handler, *args, **kwargs)
+
+    if this:
+        # pylint: disable=E1120
+        return sync_request.__get__(this, func.__class__)
+        # pylint: enable=E1120
+    return sync_request
+
+
+class RPyCRobotRemoteClient:
+    """
+    Implements Remote Client Interface for Robot Framework based on RPyC
+    """
+    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
+
+    __slot__ = ()
+
+    # pylint: disable=R0913
+    def __init__(self,
+                 peer: str = 'localhost',
+                 port: int = 18861,
+                 ipv6: bool = False,
+                 timeout=None,
+                 logger=None,
+                 **rpyc_config):
+        self._keywords_cache = None
+
+        if logger is None:
+            logger = logging.getLogger('RPyCRobotRemote.Client')
+
+        # pylint: disable=duplicate-code
+        config = {}
+        if rpyc_config:
+            config.update(rpyc_config)
+
+        config.update(
+            {
+                'allow_all_attrs': True,
+                'allow_getattr': True,
+                'allow_setattr': True,
+                'allow_delattr': True,
+                'allow_exposed_attrs': False,
+                'logger': logger,
+            }
+        )
+
+        if timeout is not None:
+            config['sync_request_timeout'] = convert_time(
+                timeout,
+                result_format='number'
+            )
+        # pylint: enable=duplicate-code
+
+        self._client = rpyc.connect(
+            peer,
+            port,
+            config=config,
+            ipv6=ipv6,
+            keepalive=True,
+        )
+
+        # automatic redirect stdout + stderr from remote during
+        # during handling of sync_request
+        self._client._is_connected = True
+        self._client._is_redirected = False
+        self._client.sync_request = redirect_output(self._client.sync_request)
+    # pylint: enable=R0913
+
+    @property
+    def __doc__(self):
+        return getattr(self._client.root.library, '__doc__')
+
+    def __getattr__(self, name: str):
+        if (name[0:1] != '_' and
+                (not name.startswith('ROBOT_LIBRARY_') or
+                 self._client._is_connected)):
+            try:
+                obj = getattr(self._client.root.library, name)
+            except AttributeError:
+                pass
+            else:
+                if name.startswith('ROBOT_LIBRARY_') or callable(obj):
+                    return obj
+        raise AttributeError(
+            f'{type(self).__name__!r} object has no attribute {name!r}'
+        )
+
+    def stop_remote_server(self):
+        """Stop remote server."""
+        self._client.root.stop_remote_server()
+        # pylint: disable=W0212
+        self._client._is_connected = False
+        # pylint: enable=W0212
+        self._client.close()
+
+    @not_keyword
+    def get_keyword_names(self):
+        """Return keyword names supported by the remote server."""
+        if self._keywords_cache is None:
+            base = set(self._client.root.get_keyword_names())
+            attributes = [(name, getattr(self, name))
+                          for name in dir(self) if name[0:1] != '_']
+            self._keywords_cache = tuple(
+                sorted(
+                    base | {
+                        name for name, value in attributes
+                        if (callable(value) and
+                            not getattr(value, 'robot_not_keyword', False))
+                    }
+                )
+            )
+        return self._keywords_cache

robotframework_rpycremote-0.0.1/RPyCRobotRemote/RPyCRobotRemoteServer.py

@@ -0,0 +1,204 @@
+"""
+Server Implementation for RPyCRobotRemote
+"""
+import sys
+import pathlib
+import logging
+import io
+import inspect
+from typing import TextIO, Optional, Union
+from robot.libraries.DateTime import convert_time
+import rpyc
+from rpyc.utils.server import ThreadedServer
+
+
+class RPyCRobotRemoteServer:
+    """
+    Implements Remote Sever Interface for Robot Framework based on RPyC
+    """
+    # pylint: disable=R0913
+    def __init__(self,  # noqa, C901 allow higher complexity here
+                 library,
+                 host: Optional[str] = 'localhost',
+                 port: int = 18861,
+                 port_file: Optional[Union[str, pathlib.Path, TextIO]] = None,
+                 serve: bool = True,
+                 allow_remote_stop: bool = True,
+                 ipv6: bool = False,
+                 timeout=None,
+                 logger=None,
+                 server=None,
+                 **rpyc_config):
+        """Configure and start-up remote server.
+
+        :param library:     Test library instance or module to host.
+        :param host:        Address to listen. Use None to listen
+                            to all available interfaces.
+        :param port:        Port to listen. Use ``0`` to select a free port
+                            automatically. Can be given as an integer or as
+                            a string.
+        :param port_file:   File to write the port that is used. ``None`` means
+                            no such file is written. Port file is created after
+                            the server is started and removed automatically
+                            after it has stopped.
+        :param serve:       If ``True``, start the server automatically and
+                            wait for it to be stopped.
+        :param allow_remote_stop:  Allow/disallow stopping the server using
+                            ``Stop Remote Server`` keyword and
+                            ``stop_remote_server`` method.
+        :param ipv6         If ``True``, allow IPv6 connections,
+                            if ``False``, use IPv4 only connections.
+        """
+        class Service(rpyc.Service):
+            """The root service provided"""
+            def __init__(self, library):
+                super().__init__()
+                self._library = library
+
+            if allow_remote_stop:
+                @staticmethod
+                def stop_remote_server():
+                    """stop server from remote"""
+                    self.stop()
+
+            def get_keyword_names(self):
+                """return the methods which can be used as keywords"""
+                get_kw_names = getattr(
+                    self._library,
+                    'get_keyword_names',
+                    None
+                )
+
+                if get_kw_names:
+                    return tuple(sorted(set(get_kw_names())))
+
+                attributes = inspect.getmembers(
+                    self._library,
+                    is_function_or_method
+                )
+                return tuple(
+                    name for name, value in attributes
+                    if (name[0:1] != '_' and
+                        not getattr(value, 'robot_not_keyword', False))
+                )
+
+            @property
+            def library(self):
+                """wrapprt to retrieve the library object from remote"""
+                return self._library
+
+            @property
+            def stdin(self):
+                """wrapprt to change stdout from remote"""
+                return sys.stdin
+
+            @stdin.setter
+            def stdin(self, value: TextIO):
+                sys.stdin = value
+
+            @property
+            def stdout(self):
+                """wrapprt to change stdout from remote"""
+                return sys.stdout
+
+            @stdout.setter
+            def stdout(self, value: TextIO):
+                sys.stdout = value
+
+            @property
+            def stderr(self):
+                """wrapprt to change stderr from remote"""
+                return sys.stderr
+
+            @stderr.setter
+            def stderr(self, value: TextIO):
+                sys.stderr = value
+
+            def _rpyc_setattr(self, name: str, value):
+                if name in ('stdin', 'stdout', 'stderr'):
+                    return setattr(self, name, value)
+                return super()._rpyc_setattr(name, value)
+
+        self._port_file = (
+            port_file if (
+                port_file is None or isinstance(port_file, io.TextIOBase))
+            else pathlib.Path(port_file).absolute()
+        )
+
+        if logger is None:
+            logger = logging.getLogger('RPyCRobotRemote.Server')
+
+        if server is None:
+            server = ThreadedServer
+
+        # pylint: disable=duplicate-code
+        config = {}
+        if rpyc_config:
+            config.update(rpyc_config)
+
+        config.update(
+            {
+                'allow_all_attrs': True,
+                'allow_getattr': True,
+                'allow_setattr': True,
+                'allow_delattr': True,
+                'allow_exposed_attrs': False,
+                'logger': logger,
+            }
+        )
+
+        if timeout is not None:
+            config['sync_request_timeout'] = convert_time(
+                timeout,
+                result_format='number'
+            )
+        # pylint: enable=duplicate-code
+
+        self._server = server(
+            Service(library),
+            hostname=host,
+            port=port,
+            ipv6=ipv6,
+            auto_register=False,
+            logger=logger,
+            protocol_config=config,
+        )
+
+        if serve:
+            self.serve()
+    # pylint: enable=R0913
+
+    def stop(self):
+        """stop serving requests"""
+        self._server.active = False
+
+    def serve(self):
+        """start serving requests"""
+        if self._port_file:
+            if isinstance(self._port_file, io.TextIOBase):
+                print(self.server_port, file=self._port_file)
+            else:
+                with self._port_file.open('w', encoding='utf-8') as f:
+                    print(self.server_port, file=f)
+        self._server.start()
+        if self._port_file and not isinstance(self._port_file, io.TextIOBase):
+            self._port_file.unlink()
+
+    @property
+    def server_address(self):
+        """Server address as a tuple ``(host, port)``."""
+        return self._server.host
+
+    @property
+    def server_port(self):
+        """Server port as an integer.
+
+        If the initial given port is 0, also this property returns 0 until
+        the server is activated.
+        """
+        return self._server.port
+
+
+def is_function_or_method(item):
+    """return True in case item is a function or method"""
+    return inspect.isfunction(item) or inspect.ismethod(item)

robotframework_rpycremote-0.0.1/RPyCRobotRemote/__init__.py

@@ -0,0 +1,58 @@
+"""
+__init__.py for RPyCRobotRemote
+"""
+from collections.abc import Iterable
+from collections import UserString
+from io import IOBase
+from rpyc.utils.server import Server as _RPyCServer
+import robot.utils
+import robot.variables.replacer
+import robot.variables.assigner
+import robot.variables.store
+from .RPyCRobotRemoteClient import RPyCRobotRemoteClient as Client
+from .RPyCRobotRemoteServer import RPyCRobotRemoteServer as Server # noqa, F401
+
+RPyCRobotRemote = Client
+
+
+class SingleServer(_RPyCServer):
+    """
+    A server that handles a single connection (blockingly)
+
+    Parameters: see :class:`rpyc.utils.server.Server`
+    """
+
+    def _accept_method(self, sock):
+        """accept method"""
+        try:
+            self._authenticate_and_serve_client(sock)
+        finally:
+            pass
+
+
+# work around problems with is_list_like and remote tuples objects
+# Python seems to have a problem with isinstance here
+# and throws expcetion
+def patch_is_list_like(func):
+    """patch is_list_like as it leads to exception with remote namedtuples"""
+    def is_list_like(item):
+        for t in (str, bytes, bytearray, UserString, IOBase):
+            try:
+                if isinstance(item, t):
+                    return False
+            except TypeError:
+                pass
+        try:
+            return isinstance(item, Iterable)
+        except TypeError:
+            pass
+        try:
+            iter(item)
+        except TypeError:
+            return False
+        return True
+
+    func.__code__ = is_list_like.__code__
+
+
+patch_is_list_like(robot.utils.is_list_like)

robotframework_rpycremote-0.0.1/RPyCRobotRemote/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)

robotframework_rpycremote-0.0.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ['setuptools>=45', 'setuptools_scm[toml]>=6.2']
+
+[project]
+name = 'robotframework-rpycremote'
+authors = [
+    {name = 'René Lehfeld', email = '54720674+rlehfeld@users.noreply.github.com'},
+]
+description = 'Robot Framework Remote Library based on RPyC'
+requires-python = '>=3.7'
+license = {text = 'MIT'}
+keywords = ['robotframework', 'robot-framework', 'rpyc']
+classifiers = [
+    'Programming Language :: Python :: 3',
+    'Environment :: Other Environment',
+    'Intended Audience :: Developers',
+    'Operating System :: OS Independent',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+]
+dependencies = [
+  'robotframework>=5.0.1',
+  'rpyc>=6.0.0',
+]
+dynamic = ['version', 'readme']
+
+[project.urls]
+'Homepage' = 'https://github.com/rlehfeld/robotframework-rpycremote'
+'Bug Reports' = 'https://github.com/rlehfeld/robotframework-rpycremote/issues'
+'Source' = 'https://github.com/rlehfeld/robotframework-rpycremote/'
+
+[tool.setuptools]
+packages = ['RPyCRobotRemote']
+
+[tool.setuptools.dynamic]
+readme = {file = ['README.rst']}
+
+[tool.setuptools_scm]
+write_to = 'RPyCRobotRemote/_version.py'

robotframework_rpycremote-0.0.1/robotframework_rpycremote.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.1
+Name: robotframework-rpycremote
+Version: 0.0.1
+Summary: Robot Framework Remote Library based on RPyC
+Author-email: René Lehfeld <54720674+rlehfeld@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rlehfeld/robotframework-rpycremote
+Project-URL: Bug Reports, https://github.com/rlehfeld/robotframework-rpycremote/issues
+Project-URL: Source, https://github.com/rlehfeld/robotframework-rpycremote/
+Keywords: robotframework,robot-framework,rpyc
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: robotframework>=5.0.1
+Requires-Dist: rpyc>=6.0.0
+
+RPyC Robot Remote Library
+============================
+Generic Robot Framework Remote library based on RPyC
+
+Installation
+============
+Install the latest release via PyPi using pip:
+
+::
+
+    pip install robotframework-rpycremote
+
+Or add to your ``conda.yaml`` file:
+
+::
+
+    - pip:
+        - robotframework-rpycremote
+
+
+In oder to help with development you can directly install from GitHub via:
+
+::
+
+    pip install git+https://github.com/rlehfeld/robotframework-rpycremote.git
+
+Or add to your ``conda.yaml`` file:
+
+::
+
+    - pip:
+        - git+https://github.com/rlehfeld/robotframework-rpycremote.git
+
+
+Usage
+=====

robotframework_rpycremote-0.0.1/robotframework_rpycremote.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+.gitignore
+LICENSE.txt
+README.rst
+pyproject.toml
+setup.py
+.github/workflows/pipeline.yml
+.github/workflows/publish-to-pypi.yml
+RPyCRobotRemote/RPyCRobotRemoteClient.py
+RPyCRobotRemote/RPyCRobotRemoteServer.py
+RPyCRobotRemote/__init__.py
+RPyCRobotRemote/_version.py
+robotframework_rpycremote.egg-info/PKG-INFO
+robotframework_rpycremote.egg-info/SOURCES.txt
+robotframework_rpycremote.egg-info/dependency_links.txt
+robotframework_rpycremote.egg-info/requires.txt
+robotframework_rpycremote.egg-info/top_level.txt
+test/client.py
+test/provider.py
+test/server.py
+test/test.robot

robotframework_rpycremote-0.0.1/robotframework_rpycremote.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

robotframework_rpycremote-0.0.1/robotframework_rpycremote.egg-info/requires.txt

@@ -0,0 +1,2 @@
+robotframework>=5.0.1
+rpyc>=6.0.0

robotframework_rpycremote-0.0.1/robotframework_rpycremote.egg-info/top_level.txt

@@ -0,0 +1 @@
+RPyCRobotRemote

robotframework_rpycremote-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

robotframework_rpycremote-0.0.1/setup.py

@@ -0,0 +1,9 @@
+'''
+setup/install instructions for pip
+'''
+from setuptools import setup
+
+setup(
+    use_scm_version=True,
+    setup_requires=['setuptools_scm'],
+)

robotframework_rpycremote-0.0.1/test/client.py

@@ -0,0 +1,19 @@
+"""
+Test Code for RPyCRobotClient via python
+"""
+import inspect
+import RPyCRobotRemote
+
+conn = RPyCRobotRemote.Client()
+print(conn.get_answer())
+print(conn.dummy_test())
+print(conn.get_region())
+print(list(conn.get_region()))
+print(conn.ROBOT_LIBRARY_DOC_FORMAT)
+print(conn.__doc__)
+print(conn.get_answer())
+print(dir(conn))
+
+print(inspect.getmembers(conn, callable))
+
+conn.stop_remote_server()

robotframework_rpycremote-0.0.1/test/provider.py

@@ -0,0 +1,89 @@
+"""
+Sample service Provide() used for testing RPyCRobot client and server
+"""
+import numbers
+from collections import namedtuple
+from robot.api.deco import keyword, not_keyword
+
+
+class Region(namedtuple('Region', 'x y width height')):
+    """
+    namedtuple to reproduce problem in list assignment
+    with robot framework
+    """
+    def __new__(cls, *args):
+        if not all(isinstance(x, numbers.Integral) for x in args):
+            raise TypeError('all parameters must be of type int')
+        return super(Region, cls).__new__(cls, *args)
+
+
+class Provider:
+    """dummy test implementation"""
+    ROBOT_LIBRARY_DOC_FORMAT = 'text'
+
+    the_real_answer_though = 43
+
+    class Dummy:
+        """dummy class"""
+        def __init__(self):
+            self._value = 1
+            self.value2 = 5
+
+        @property
+        def value(self):
+            """value getter"""
+            print('called value getter')
+            return self._value
+
+        @value.setter
+        def value(self, v):
+            print('called value setter')
+            self._value = v
+
+        def __call__(self, *args, **kwargs):
+            """callable object"""
+            print(f'called __call__({args}, {kwargs})')
+            return '__call__'
+
+        def method(self, *args, **kwargs):
+            """and some callable method"""
+            print(f'called method({args}, {kwargs})')
+            return 'method'
+
+    dummy_dict = {
+        'key': 'value'
+    }
+
+    def __init__(self):
+        pass
+
+    @not_keyword
+    def help_method(self):
+        """help_method sample non keyword"""
+        print('should not be existing')
+
+    @keyword(name='Use Other Name')
+    def renamed_keyword(self):
+        """sample renmaed keyword"""
+        print('via different name')
+
+    def get_answer(self, a=42, b: int = 56, /, *args, c: int = 59):
+        """keyword which requires different arguments and return something"""
+        print(f'from remote {b} {args=}')
+        return a, c
+
+    def get_region(self):
+        """keyword which return a region"""
+        return Region(1, 2, 3, 4)
+
+    def raise_error(self):
+        """keyword which raises an error"""
+        raise RuntimeError('error')
+
+    def get_question(self):
+        """keyword which returns a string"""
+        return "what is the airspeed velocity of an unladen swallow?"
+
+    def dummy_test(self):
+        """keyword which returns an object"""
+        return self.Dummy()

robotframework_rpycremote-0.0.1/test/server.py

@@ -0,0 +1,48 @@
+"""
+Test Code for RPyCRobotServer
+"""
+import sys
+import logging
+import logging.config
+import yaml
+from provider import Provider
+import RPyCRobotRemote
+
+
+LOGCONFIG = """
+version: 1
+formatters:
+  simple:
+    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+handlers:
+  console:
+    class: logging.StreamHandler
+    level: DEBUG
+    formatter: simple
+    stream: ext://sys.__stderr__
+loggers:
+  RPyCRobotRemote:
+    level: INFO
+    handlers: [console]
+    propagate: no
+root:
+  level: DEBUG
+  handlers: [console]
+"""
+
+logging.config.dictConfig(
+    yaml.load(
+        LOGCONFIG,
+        Loader=yaml.SafeLoader
+    ),
+)
+
+server = RPyCRobotRemote.Server(
+    Provider(),
+    serve=False,
+    # port=0,
+    port_file=sys.stdout,
+    server=RPyCRobotRemote.SingleServer
+)
+
+server.serve()

robotframework_rpycremote-0.0.1/test/test.robot

@@ -0,0 +1,35 @@
+*** Settings ***
+Library    RPyCRobotRemote    localhost    18861    timeout=10 min    WITH NAME    RPyCTest
+
+*** Test Cases ***
+Test Remote
+    RPyCTest.Get Answer
+    RPyCTest.Use Other Name
+
+    ${obj} =    RPyCTest.Dummy Test
+    Log    ${obj.value}
+    ${ret} =    Call Method    ${obj}   method    1    ${2}    3    key=${5}
+    ${ret} =    Call Method    ${obj}    __call__    1    ${2}    3    key=${None}
+    ${obj.value}     Set Variable    ${5}
+    Log    ${obj.value2}
+    ${obj.value2}     Set Variable    ${10}
+
+Test Region Scalar
+    ${region}    RPyCTest.Get Region
+
+Test Region List
+    ${region}    RPyCTest.Get Region
+    @{region}    Set Variable    ${{tuple($region)}}
+
+Test Region Array via Scalar
+    ${region}    RPyCTest.Get Region
+    Log Many    @{region}
+
+Test Region Array
+    @{region}    RPyCTest.Get Region
+
+Test Exception
+    Run Keyword And Expect Error    *    RPyCTest.Raise Error
+
+Test Stop Server
+    RPyCTest.Stop Remote Server