cgse 2023.38.0__tar.gz → 2024.1.3__tar.gz

cgse-2024.1.3/.gitignore

@@ -0,0 +1,20 @@
+.python-version
+.envrc
+
+build
+dist
+
+.DS_Store
+
+__pycache__
+.pytest_cache
+
+.env
+.venv
+venv
+
+.idea
+
+**/*.egg-info
+
+uv.lock

cgse-2024.1.3/NOTES.md

@@ -0,0 +1,124 @@
+# The monorepo structure
+
+Currently, the structure starts with two folders in the root, i.e. `libs` and `projects`. Where _libs_ contains library type packages like common modules, small generic gui functions, reference frames, ... and _projects_ contain packages that build upon these libraries and can be device drivers or stand-alone applications.
+
+There is one package that I think doesn't fit into this picture, that is `cgse-core`. This is not a library, but a – collection of – service(s). So, we might want to add a third top-level folder `services` but I also fear that this again more complicates the monorepo.
+
+Anyway, the overall structure of the monorepo is depicted below:
+
+```
+cgse/
+│── pyproject.toml
+├── libs/
+│   ├── cgse-common/
+│   │   ├── src/
+│   │   ├── tests/
+│   │   └── pyproject.toml
+│   ├── cgse-core/
+│   ├── cgse-coordinates/
+│   └── cgse-gui/
+│
+└── projects/
+    ├── generic/
+    │   ├── cgse-tools/
+    │   └── symetrie-hexapod/
+    └── plato/
+        ├── plato-spw/
+        ├── plato-fits/
+        └── plato-hdf5/
+```
+
+We will discuss the structure of individual packages in a later section, for now let's look at the root of the monorepo. The root also contains a `pyproject.toml` file although this is not a package that will be build and published. The purpose of this root `pyproject.toml` file is to define properties that are used to build the full repo or any individual package in it. In the root folder we will also put some maintenance/management scripts to help you maintain and bump versions of the projects, build and publish all projects, create and maintain a changelog etc.
+
+# Package Structure
+
+We try to keep the package structure as standard as possible and consistent over the whole monorepo. The structure currently is as follows (example from cgse-common):
+
+```
+├── README.md
+├── dist
+│   ├── cgse_common-2023.1.4-py3-none-any.whl
+│   └── cgse_common-2023.1.4.tar.gz
+├── pyproject.toml
+├── src/
+│   └── egse/  # namespace
+│       ├── modules (*.py)
+│       └── <sub-packages>/
+└── tests/
+    ├── data
+    └── pytest modules (test_*.py)
+```
+
+Note that each library or project is a standalone Poetry package with its own `pyproject.toml` file, source code and unit tests.
+
+# Package versions
+
+All packages in the monorepo will have the same version. This can be maintained with the `bump.py` script. This script will read the version from the `pyproject.toml` file at the root of the monorepo and propagate the version to all libs and projects in the monorepo. Note that you –for now– will have to update the version number in the `pyproject.toml` file  located at the monorepo root folder manually. 
+
+# Use of Poetry (DEPRECATED: see below)
+
+I have now Poetry configurations for all `libs` in this monorepo. So, how do we use Poetry in this project?
+
+First thing to understand, Poetry is a development and dependency management tool. So, if you are installing the different packages in this repo from PyPI there is no need to use Poetry. The package will be installed in your current virtual environment.
+
+You can choose how you want to manage your virtual environments for each of the packages in the monorepo. I personally use `pyenv` to manage my virtual environments and I disable the virtual environment that would normally be used by Poetry.
+
+> Explain how to use `pyenv` for your virtual environments
+
+The following command starts a new sub-shell and activates the virtual environment: 
+```
+$ poetry shell
+```
+
+If you do not want to start a new shell, but just want to execute a command in the virtual environment, use the `poetry run` command, e.g.
+```
+$ poetry run pytest tests/test_bits.py
+```
+Or
+```
+$ poetry run python -m egse.monitoring localhost 6001
+```
+
+# Build and Publish
+
+Building a source distribution and a wheel for your project is as easy as running the following command:
+```
+$ pipx run build
+* Creating isolated environment: venv+pip...
+* Installing packages in isolated environment:
+  - hatchling
+* Getting build dependencies for sdist...
+* Building sdist...
+* Building wheel from sdist
+* Creating isolated environment: venv+pip...
+* Installing packages in isolated environment:
+  - hatchling
+* Getting build dependencies for wheel...
+* Building wheel...
+```
+Make sure you have updated/bumped the version number in the `pyproject.toml`. Publishing your package on PyPI needs some more preparation, since you need to prepare a token that allows you to upload your project to PyPI. Publishing itself is a peace of cake when the credentials have been configured correctly. Poetry will also automatically take the latest version to publish.
+```
+$ pipx run twine publish
+Publishing cgse-common (2023.1.5) to PyPI
+ - Uploading cgse_common-2023.1.5-py3-none-any.whl 100%
+ - Uploading cgse_common-2023.1.5.tar.gz 100%
+```
+
+# The egse namespace
+
+You might have notices that all packages in this monorepo have a `src/egse` folder in which they maintain their source code, preferably in a sub-package. Note that the `egse` folder is not a normal Python package but a namespace. There are two important facts you need to remember about namespaces:
+
+1. A namespace package **does not** contain an `__init__.py` module, never, in any of the packages in this or any other repo. If you place an `__init__.py` module in one of your `egse` package folders, you will break the namespace and therefore also the external contributions in plugins etc.
+2. A namespace package is spread out over several directories that can reside in different packages as distributed by PyPI.
+
+# Questions
+
+What is the meaning of the common egse root folder in this monorepo and when the packages are installed through PyPI?
+
+* do we still need `get_common_egse_root()`
+
+    NO, this has nothing to do with a generic common egse and also the concept of a project root folder doesn't really work for PyPI projects, especially in a monorepo. What might work in this specific case is to use the egse namespace as a root and find folders and files in the folders that make up the namespace.
+
+* what is the Projects root directory?
+
+    This folder basically contains device implementations and plugins for e.g. the storage manager.

cgse-2024.1.3/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: cgse
+Version: 2024.1.3
+Summary: Generic Common-EGSE: Commanding and monitoring lab equipment
+Author-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: rich>=13.9.4
+Requires-Dist: tomlkit
+Provides-Extra: dev
+Requires-Dist: pipdeptree; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Common-EGSE
+
+This is a monorepo with all the code and documentation for the common egse framework.
+
+This repository is organized in two main areas, `libs` and `projects`. The `libs` folder contains library type 
+packages like common modules, small generic gui functions, reference frames, etc. and `projects` contains packages 
+that build upon these libraries and can be device drivers or stand-alone applications.
+
+In the `libs` folder, we have the following packages:
+
+- `cgse-common`: Common modules and functions for the EGSE framework.
+- `cgse-coordinates`: Coordinate systems and transformations.
+- `cgse-core`: Core services for the EGSE framework.
+- `cgse-gui`: GUI functions for the EGSE framework.
+
+The `projects` folder contains generic and project specific packages. 
+
+We have the following generic packages:
+
+- `cgse-tools`: Tools for the `cgse` command.
+- `symetrie-hexapod`: The Symétrie Hexapod drivers. We put this in the generic folder because it is a generic device driver that can be used by different projects.
+
+We have the following project specific packages:
+
+- `plato-spw`: The PLATO SpaceWire drivers.
+- `plato-fits`: The PLATO FITS plugins.
+- `plato-hdf5`: The PLATO HDF5 plugins.

cgse-2024.1.3/README.md

@@ -0,0 +1,27 @@
+# Common-EGSE
+
+This is a monorepo with all the code and documentation for the common egse framework.
+
+This repository is organized in two main areas, `libs` and `projects`. The `libs` folder contains library type 
+packages like common modules, small generic gui functions, reference frames, etc. and `projects` contains packages 
+that build upon these libraries and can be device drivers or stand-alone applications.
+
+In the `libs` folder, we have the following packages:
+
+- `cgse-common`: Common modules and functions for the EGSE framework.
+- `cgse-coordinates`: Coordinate systems and transformations.
+- `cgse-core`: Core services for the EGSE framework.
+- `cgse-gui`: GUI functions for the EGSE framework.
+
+The `projects` folder contains generic and project specific packages. 
+
+We have the following generic packages:
+
+- `cgse-tools`: Tools for the `cgse` command.
+- `symetrie-hexapod`: The Symétrie Hexapod drivers. We put this in the generic folder because it is a generic device driver that can be used by different projects.
+
+We have the following project specific packages:
+
+- `plato-spw`: The PLATO SpaceWire drivers.
+- `plato-fits`: The PLATO FITS plugins.
+- `plato-hdf5`: The PLATO HDF5 plugins.

cgse-2024.1.3/TODO.md

@@ -0,0 +1,3 @@
+# TODO
+
+* [x] we will use one global version for the monorepo -> create a bump script that updates all version numbers from the master pyproject.toml

cgse-2024.1.3/bump.py

@@ -0,0 +1,77 @@
+"""
+This script bumps the version of all libs and projects in this monorepo to the version that
+is currently in the `pyproject.toml` file in the root folder of the monorepo.
+
+Usage:
+    $ python bump.py
+
+Note:
+    You are expected to be in the minimal virtual environment associated with this monorepo,
+    being a `pyenv` or Poetry environment, or your global environment shall include the tomlkit
+    and the rich package.
+
+"""
+
+import os
+import pathlib
+import subprocess
+
+import rich
+import tomlkit
+import tomlkit.exceptions
+
+
+def get_master_version(master_pyproject_path):
+    """Returns the version number of the master project, i.e. cgse."""
+
+    with open(master_pyproject_path, 'r') as file:
+        data = tomlkit.parse(file.read())
+
+    return data['project']['version']
+
+
+def update_project_version(project_dir, new_version):
+    """Updates the version of the subproject."""
+
+    os.chdir(project_dir)
+
+    # Check if the Poetry version is defined, otherwise print a message.
+
+    with open("pyproject.toml", 'r') as file:
+        data = tomlkit.parse(file.read())
+
+    try:
+        data['project']['version'] = new_version
+
+        with open('pyproject.toml', 'w') as file:
+            tomlkit.dump(data, file)
+
+    except tomlkit.exceptions.NonExistentKey:
+        rich.print(f"[red]\[project.version] is not defined in pyproject.toml in {project_dir}[/]")
+
+
+def update_all_projects_in_monorepo(root_dir):
+    """Updates all pyproject.toml files with the master version number."""
+
+    master_version = get_master_version(os.path.join(root_dir, 'pyproject.toml'))
+
+    rich.print(f"Projects will be bumped to version {master_version}")
+
+    for subdir, dirs, files in os.walk(root_dir):
+        if subdir == '.' or subdir == '..' or subdir == '__pycache__' or ".venv" in subdir or ".git" in subdir:
+            continue
+        if 'pyproject.toml' in files and subdir != str(root_dir):  # Skip the master pyproject.toml
+            print(f"Updating version for project in {subdir}")
+            update_project_version(subdir, master_version)
+
+
+if __name__ == "__main__":
+
+    monorepo_root = pathlib.Path(__file__).parent.resolve()
+
+    cwd = os.getcwd()
+    os.chdir(monorepo_root)
+
+    update_all_projects_in_monorepo(monorepo_root)
+
+    os.chdir(cwd)

cgse-2024.1.3/libs/cgse-common/README.md

@@ -0,0 +1,39 @@
+
+![PyPI - Version](https://img.shields.io/pypi/v/cgse-common)
+![Supported OS](https://img.shields.io/badge/Supported%20OS-Linux%20%7C%20macOS-blue)
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FIvS-KULeuven%2Fcgse%2Frefs%2Fheads%2Fmain%2Fpyproject.toml)
+![PyPI - Wheel](https://img.shields.io/pypi/wheel/cgse-common)
+
+# Generic Functionality used in the Common-EGSE
+
+This package 'cgse-common' contains functionality that is used by all `cgse` sub-packages, but it is designed to be a stand-alone generic package that can be used also in any other project.
+
+
+## Installation
+
+Install the package using pip:
+
+    $ pip install cgse-common
+
+
+## Usage
+
+All functionality resides in the package `egse`. As an example, if you need a standard way to format your timestamp, use the `format_datetime()` function from `egse.system`:
+
+    >>> from egse.system import format_datetime
+    >>> print(format_datetime())
+    2023-10-10T08:41:51.937+0000
+
+
+## Included Functionality
+
+A non-comprehensive list of available functionality:
+
+### Functionality of General Use
+
+* **egse.bits**: contains a number of convenience functions to work with bits, bytes and integers
+* **egse.decorators**: a collection of useful decorator functions
+* **egse.reload**: a slightly better approach to reloading modules and function than the standard importlib.reload() function.
+* **egse.resource**: provides convenience functions to use resources in your code without the need to specify an absolute path
+* **egse.system**: defines convenience functions that provide information on system specific functionality like, file system interactions, timing, operating system interactions, etc.
+* **egse.version**: functionality to retrieve the package version information

cgse-2024.1.3/libs/cgse-common/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "cgse-common"
+version = "2024.1.3"
+description = "Software framework to support hardware testing"
+authors = [
+    {name = "IVS KU Leuven"}
+]
+maintainers = [
+    {name = "Rik Huygen", email = "rik.huygen@kuleuven.be"},
+    {name = "Sara Regibo", email = "sara.regibo@kuleuven.be"}
+]
+readme = {"file" = "README.md", "content-type" = "text/markdown"}
+requires-python = ">=3.9"
+license = "MIT"
+keywords = [
+    "CGSE",
+    "Common-EGSE",
+    "hardware testing",
+    "software framework"
+]
+dependencies = [
+    "click",
+    "deepdiff",
+    "distro",
+    "gitpython",
+    "numpy == 1.22.4", # only used in setup
+    "pandas",
+    "pip>=24.3.1", # only used in setup
+    "prometheus-client",
+    "psutil",
+    "pyyaml",
+    "pyzmq == 23.2.1",
+    "rich",
+]
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-mock", "pytest-cov"]
+dev = ["pipdeptree", "tomlkit", "ruff"]
+
+[project.entry-points."cgse.version"]
+cgse-common = 'egse'
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "/tests",
+    "/pytest.ini",
+    "/.gitignore",
+    "/*poetry*",
+    "/*setuptools*",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/egse"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+extend-select = ["E501"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

cgse-2024.1.3/libs/cgse-common/pytest.ini

@@ -0,0 +1,11 @@
+# Configuration file for pytest
+
+[pytest]
+# report all + passed (incl. output)
+addopts = -rapP
+log_cli = 0
+log_level = INFO
+# log_format = %(asctime)s %(levelname)s %(message)s
+log_format = %(asctime)s.%(msecs)03d %(levelname)-8s %(lineno)-6d %(filename)-20s %(funcName)10s: %(message)s
+# log_date_format = %Y-%m-%d %H:%M:%S
+markers = slow: marks tests as slow (deselect with '-m "not slow"')

{cgse-2023.38.0 → cgse-2024.1.3/libs/cgse-common}/src/egse/command.py

@@ -18,7 +18,7 @@ interpreted differently. See further: How to format device command strings.
 
 the base class for commands. This class contains the definition of the command
 and provides methods to parse and check arguments. The Command can be 'called'
-or 'executed' in which case a number of actons are performed based on the
+or 'executed' in which case a number of actions are performed based on the
 provided arguments.
 
 **CommandExecution**

{cgse-2023.38.0 → cgse-2024.1.3/libs/cgse-common}/src/egse/config.py

@@ -4,13 +4,9 @@ and to find paths and resources.
 """
 from __future__ import annotations
 
-import errno
 import fnmatch
 import logging
 import os
-from functools import lru_cache
-from os.path import exists
-from os.path import join
 from pathlib import Path
 from pathlib import PurePath
 from typing import List
@@ -18,10 +14,8 @@ from typing import Optional
 from typing import Tuple
 from typing import Union
 
-import git
-
-HERE = Path(__file__).parent.resolve()
-MODULE_LOGGER = logging.getLogger(__name__)
+_HERE = Path(__file__).parent.resolve()
+_LOGGER = logging.getLogger(__name__)
 
 
 def find_first_occurrence_of_dir(pattern: str, root: Path | str = None) -> Optional[Path]:
@@ -43,7 +37,7 @@ def find_first_occurrence_of_dir(pattern: str, root: Path | str = None) -> Optio
     """
     import fnmatch
 
-    root = Path(root).resolve() if root else HERE
+    root = Path(root).resolve() if root else _HERE
     if not root.is_dir():
         root = root.parent
 
@@ -171,7 +165,7 @@ def find_files(pattern: str, root: str = None, in_dir: str = None):
 
 def find_file(name: str, root: str = None, in_dir: str = None) -> Optional[Path]:
     """
-    Find the path to the given file starting from the root directory of the Common-EGSE
+    Find the path to the given file starting from the root directory of the
     distribution.
 
     Note that if there are more files with the given name found in the distribution,
@@ -239,122 +233,6 @@ def find_root(
     return Path(default) if default is not None else None
 
 
-@lru_cache(maxsize=16)
-def get_common_egse_root(path: Union[str, PurePath] = None) -> Optional[PurePath]:
-    """
-    Returns the absolute path to the installation directory for the Common-EGSE.
-
-    The algorithm first tries to determine the path from the environment variable
-    ``PLATO_COMMON_EGSE_PATH``. If this environment variable doesn't exist, the algorithm
-    tries to determine the path automatically from (1) the git root if it is a git repository,
-    or (2) from the location of this module assuming the installation is done from the
-    GitHub distribution.
-
-    When the optional argument ``path`` is given, that directory will be used to start the
-    search for the root folder.
-
-    At this moment the algorithm does not cache the ``egse_path`` in order to speed up
-    the successive calls to this function.
-
-    Args:
-        path (str or Path): a directory as a Path or str [optional]
-
-    Returns:
-        Path: the absolute path to the Common-EGSE installation directory or None
-    """
-    _TEST_NAMES = ("pyproject.toml", "setup.py")
-    if path is not None:
-        return find_root(path, tests=_TEST_NAMES)
-
-    egse_path: Union[str, PurePath, None] = os.getenv("PLATO_COMMON_EGSE_PATH")
-
-    if egse_path is None:
-
-        # The root of the plato-common-egse installation shall be determined from the location
-        # of this config module using git commands to find the git root folder.
-        # This assumes the user has installed from git/GitHub (which is not always true)!
-        #
-        # Alternatively, the root directory can be determined from the location of this module
-        # by going back in the directory structure until the ``setup.py`` module is found.
-
-        _THIS_FILE_PATH = Path(__file__).resolve()
-        _THIS_FILE_LOCATION = _THIS_FILE_PATH.parent
-
-        try:
-            git_repo = git.Repo(_THIS_FILE_PATH, search_parent_directories=True)
-            git_root = git_repo.git.rev_parse("--show-toplevel")
-            egse_path = git_root
-        except (git.exc.InvalidGitRepositoryError, git.exc.NoSuchPathError):
-            MODULE_LOGGER.info("no git repository found, assuming installation from distribution.")
-            egse_path = find_root(_THIS_FILE_LOCATION, tests=_TEST_NAMES)
-
-        MODULE_LOGGER.debug(f"Common-EGSE location is automatically determined: {egse_path}.")
-
-    else:
-        MODULE_LOGGER.debug(
-            f"Common-EGSE location determined from environment variable "
-            f"PLATO_COMMON_EGSE_PATH: {egse_path}"
-        )
-
-    return Path(egse_path)
-
-
-def get_resource_dirs(root_dir: Union[str, PurePath] = None) -> List[Path]:
-    """
-    Define directories that contain resources like images, icons, and data files.
-
-    Resource directories can have the following names: `resources`, `data`, `icons`, or `images`.
-    This function checks if any of the resource directories exist in the project root directory,
-    in the `root_dir` that is given as an argument or in the `src/egse` sub-folder.
-
-    So, the directories that are searched for the resource folders are:
-
-    * `root_dir` or the project's root directory
-    * the `src/egse` sub-folder of one of the above
-
-    For all existing directories the function returns the absolute path.
-
-    Args:
-        root_dir (str): the directory to search for resource folders
-
-    Returns:
-        a list of absolute Paths.
-    """
-    project_dir = Path(root_dir).resolve() if root_dir else get_common_egse_root()
-    result = []
-    for dir_ in ["resources", "data", "icons", "images"]:
-        if (project_dir / dir_).is_dir():
-            result.append(Path(project_dir, dir_).resolve())
-        if (project_dir / "src" / "egse" / dir_).is_dir():
-            result.append(Path(project_dir, "src", "egse", dir_).resolve())
-    return result
-
-
-def get_resource_path(name: str, resource_root_dir: Union[str, PurePath] = None) -> PurePath:
-    """
-    Searches for a data file (resource) with the given name.
-
-    When `resource_root_dir` is not given, the search for resources will start at the root
-    folder of the project (using the function `get_common_egse_root()`). Any other root
-    directory can be given, e.g. if you want to start the search from the location of your
-    source code file, use `Path(__file__).parent` as the `resource_root_dir` argument.
-
-    Args:
-        name (str): the name of the resource that is requested
-        resource_root_dir (str): the root directory where the search for resources should be started
-
-    Returns:
-        the absolute path of the data file with the given name. The first name that matches
-        is returned. If no file with the given name or path exists, a FileNotFoundError is raised.
-
-    """
-    for resource_dir in get_resource_dirs(resource_root_dir):
-        resource_path = join(resource_dir, name)
-        if exists(resource_path):
-            return Path(resource_path).absolute()
-    raise FileNotFoundError(errno.ENOENT, f"Could not locate resource '{name}'")
-
-
 def set_logger_levels(logger_levels: List[Tuple] = None):
     """
     Set the logging level for the given loggers.
@@ -368,7 +246,8 @@ def set_logger_levels(logger_levels: List[Tuple] = None):
 
 
 class WorkingDirectory:
-    """WorkingDirectory is a context manager to temporarily change the working directory while
+    """
+    WorkingDirectory is a context manager to temporarily change the working directory while
     executing some code.
 
     This context manager has a property `path` which returns the absolute path of the
@@ -402,7 +281,7 @@ class WorkingDirectory:
         try:
             os.chdir(self._current_dir)
         except OSError as exc:
-            MODULE_LOGGER.warning(f"Change back to previous directory failed: {exc}")
+            _LOGGER.warning(f"Change back to previous directory failed: {exc}")
 
     @property
     def path(self):