pyedb 0.2.0__py3-none-any.whl

pyedb/generic/data_handlers.py

@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+from collections import OrderedDict
+from decimal import Decimal
+import json
+import math
+import random
+import re
+import string
+
+from pyedb.generic.general_methods import pyedb_function_handler, settings
+
+
+@pyedb_function_handler()
+def format_decimals(el):  # pragma: no cover
+    """
+
+    Parameters
+    ----------
+    el :
+
+
+    Returns
+    -------
+
+    """
+    if float(el) > 1000:
+        num = "{:,.0f}".format(Decimal(el))
+    elif float(el) > 1:
+        num = "{:,.3f}".format(Decimal(el))
+    else:
+        num = "{:.3E}".format(Decimal(el))
+    return num
+
+
+@pyedb_function_handler()
+def random_string(length=6, only_digits=False, char_set=None):  # pragma: no cover
+    """Generate a random string
+
+    Parameters
+    ----------
+    length :
+        length of the random string (Default value = 6)
+    only_digits : bool, optional
+        ``True`` if only digits are to be included.
+    char_set : str, optional
+        Custom character set to pick the characters from.  By default chooses from
+        ASCII and digit characters or just digits if ``only_digits`` is ``True``.
+
+    Returns
+    -------
+    type
+        random string
+
+    """
+    if not char_set:
+        if only_digits:
+            char_set = string.digits
+        else:
+            char_set = string.ascii_uppercase + string.digits
+    random_str = "".join(random.choice(char_set) for _ in range(int(length)))
+    return random_str
+
+
+@pyedb_function_handler()
+def unique_string_list(element_list, only_string=True):  # pragma: no cover
+    """Return a unique list of strings from an element list.
+
+    Parameters
+    ----------
+    element_list :
+
+    only_string :
+         (Default value = True)
+
+    Returns
+    -------
+
+    """
+    if element_list:
+        if isinstance(element_list, list):
+            element_list = set(element_list)
+        elif isinstance(element_list, str):
+            element_list = [element_list]
+        else:
+            error_message = "Invalid list data"
+            try:
+                error_message += " {}".format(element_list)
+            except:
+                pass
+            raise Exception(error_message)
+
+        if only_string:
+            non_string_entries = [x for x in element_list if type(x) is not str]
+            assert not non_string_entries, "Invalid list entries {} are not a string!".format(non_string_entries)
+
+    return element_list
+
+
+@pyedb_function_handler()
+def string_list(element_list):  # pragma: no cover
+    """
+
+    Parameters
+    ----------
+    element_list :
+
+
+    Returns
+    -------
+
+    """
+    if isinstance(element_list, str):
+        element_list = [element_list]
+    else:
+        assert isinstance(element_list, str), "Input must be a list or a string"
+    return element_list
+
+
+@pyedb_function_handler()
+def ensure_list(element_list):  # pragma: no cover
+    """
+
+    Parameters
+    ----------
+    element_list :
+
+
+    Returns
+    -------
+
+    """
+    if not isinstance(element_list, list):
+        element_list = [element_list]
+    return element_list
+
+
+@pyedb_function_handler()
+def from_rkm(code):  # pragma: no cover
+    """Convert an RKM code string to a string with a decimal point.
+
+    Parameters
+    ----------
+    code : str
+        RKM code string.
+
+    Returns
+    -------
+    str
+        String with a decimal point and an R value.
+
+    Examples
+    --------
+    >>> from_rkm('R47')
+    '0.47'
+
+    >>> from_rkm('4R7')
+    '4.7'
+
+    >>> from_rkm('470R')
+    '470'
+
+    >>> from_rkm('4K7')
+    '4.7k'
+
+    >>> from_rkm('47K')
+    '47k'
+
+    >>> from_rkm('47K3')
+    '47.3k'
+
+    >>> from_rkm('470K')
+    '470k'
+
+    >>> from_rkm('4M7')
+    '4.7M'
+
+    """
+
+    # Matches RKM codes that start with a digit.
+    # fd_pattern = r'([0-9]+)([LREkKMGTFmuµUnNpP]+)([0-9]*)'
+    fd_pattern = r"([0-9]+)([{}]+)([0-9]*)".format(
+        "".join(RKM_MAPS.keys()),
+    )
+    # matches rkm codes that end with a digit
+    # ld_pattern = r'([0-9]*)([LREkKMGTFmuµUnNpP]+)([0-9]+)'
+    ld_pattern = r"([0-9]*)([{}]+)([0-9]+)".format("".join(RKM_MAPS.keys()))
+
+    fd_regex = re.compile(fd_pattern, re.I)
+    ld_regex = re.compile(ld_pattern, re.I)
+
+    for regex in [fd_regex, ld_regex]:
+        m = regex.match(code)
+        if m:
+            fd, base, ld = m.groups()
+            ps = RKM_MAPS[base]
+
+            if ld:
+                return_str = "".join([fd, ".", ld, ps])
+            else:
+                return_str = "".join([fd, ps])
+            return return_str
+    return code
+
+
+def str_to_bool(s):  # pragma: no cover
+    """Convert a ``"True"`` or ``"False"`` string to its corresponding Boolean value.
+
+    If the passed arguments are not relevant in the context of conversion, the argument
+    itself is returned. This method can be called using the ``map()`` function to
+    ensure conversion of Boolean strings in a list.
+
+    Parameters
+    ----------
+    s: str
+
+    Returns
+    -------
+    bool or str
+         The method is not case-sensitive.
+         - ``True`` is returned  if the input is ``"true"``, ``"1"``,
+           `"yes"``, or ``"y"``,
+         - ``False`` is returned if the input is ``"false"``, ``"no"``,
+           ``"n``,  or ``"0"``.
+         - Otherwise, the input value is passed through the method unchanged.
+
+    """
+    if type(s) == str:
+        if s.lower() in ["true", "yes", "y", "1"]:
+            return True
+        elif s.lower() in ["false", "no", "n", "0"]:
+            return False
+        else:
+            return s
+    elif type(s) == int:
+        return False if s == 0 else True
+
+
+unit_val = {
+    "": 1.0,
+    "uV": 1e-6,
+    "mV": 1e-3,
+    "V": 1.0,
+    "kV": 1e3,
+    "MegV": 1e6,
+    "ns": 1e-9,
+    "us": 1e-6,
+    "ms": 1e-3,
+    "s": 1.0,
+    "min": 60,
+    "hour": 3600,
+    "rad": 1.0,
+    "deg": math.pi / 180,
+    "Hz": 1.0,
+    "kHz": 1e3,
+    "MHz": 1e6,
+    "nm": 1e-9,
+    "um": 1e-6,
+    "mm": 1e-3,
+    "in": 0.0254,
+    "inches": 0.0254,
+    "mil": 2.54e-5,
+    "cm": 1e-2,
+    "dm": 1e-1,
+    "meter": 1.0,
+    "km": 1e3,
+}
+
+
+@pyedb_function_handler()
+def float_units(val_str, units=""):  # pragma: no cover
+    """Retrieve units for a value.
+
+    Parameters
+    ----------
+    val_str : str
+        Name of the float value.
+
+    units : str, optional
+         The default is ``""``.
+
+    Returns
+    -------
+
+    """
+    if not units in unit_val:
+        raise Exception("Specified unit string " + units + " not known!")
+
+    loc = re.search("[a-zA-Z]", val_str)
+    try:
+        b = loc.span()[0]
+        var = [float(val_str[0:b]), val_str[b:]]
+        val = var[0] * unit_val[var[1]]
+    except:
+        val = float(val_str)
+
+    val = val / unit_val[units]
+    return val
+
+
+@pyedb_function_handler()
+def json_to_dict(fn):  # pragma: no cover
+    """Load Json File to a dictionary.
+
+    Parameters
+    ----------
+    fn : str
+        json file full path.
+
+    Returns
+    -------
+    dict
+    """
+    json_data = {}
+    with open(fn) as json_file:
+        try:
+            json_data = json.load(json_file)
+        except json.JSONDecodeError as e:  # pragma: no cover
+            error = "Error reading json: {} at line {}".format(e.msg, e.lineno)
+            settings.logger.error(error)
+    return json_data

pyedb/generic/design_types.py

@@ -0,0 +1,104 @@
+import os
+
+
+# lazy imports
+def Edb(
+    edbpath=None,
+    cellname=None,
+    isreadonly=False,
+    edbversion=None,
+    isaedtowned=False,
+    oproject=None,
+    student_version=False,
+    use_ppe=False,
+    technology_file=None,
+):
+    """Provides the EDB application interface.
+
+    This module inherits all objects that belong to EDB.
+
+    Parameters
+    ----------
+    edbpath : str, optional
+        Full path to the ``aedb`` folder. The variable can also contain
+        the path to a layout to import. Allowed formats are BRD,
+        XML (IPC2581), GDS, and DXF. The default is ``None``.
+        For GDS import, the Ansys control file (also XML) should have the same
+        name as the GDS file. Only the file extension differs.
+    cellname : str, optional
+        Name of the cell to select. The default is ``None``.
+    isreadonly : bool, optional
+        Whether to open EBD in read-only mode when it is
+        owned by HFSS 3D Layout. The default is ``False``.
+    edbversion : str, optional
+        Version of EDB to use. The default is ``"2021.2"``.
+    isaedtowned : bool, optional
+        Whether to launch EDB from HFSS 3D Layout. The
+        default is ``False``.
+    oproject : optional
+        Reference to the AEDT project object.
+    student_version : bool, optional
+        Whether to open the AEDT student version. The default is ``False.``
+    technology_file : str, optional
+        Full path to technology file to be converted to xml before importing or xml. Supported by GDS format only.
+
+    Returns
+    -------
+    :class:`pyedb.dotnet.edb.Edb`, :class:`pyedb.grpc.edb.Edb`
+
+    Examples
+    --------
+    Create an ``Edb`` object and a new EDB cell.
+
+    >>> from pyedb import Edb
+    >>> app = Edb()
+
+    Add a new variable named "s1" to the ``Edb`` instance.
+
+    >>> app['s1'] = "0.25 mm"
+    >>> app['s1'].tofloat
+    >>> 0.00025
+    >>> app['s1'].tostring
+    >>> "0.25mm"
+
+    or add a new parameter with description:
+
+    >>> app['s2'] = ["20um", "Spacing between traces"]
+    >>> app['s2'].value
+    >>> 1.9999999999999998e-05
+    >>> app['s2'].description
+    >>> 'Spacing between traces'
+
+
+    Create an ``Edb`` object and open the specified project.
+
+    >>> app = Edb("myfile.aedb")
+
+    Create an ``Edb`` object from GDS and control files.
+    The XML control file resides in the same directory as the GDS file: (myfile.xml).
+
+    >>> app = Edb("/path/to/file/myfile.gds")
+
+    """
+
+    # Use EDB legacy (default choice)
+    if bool(os.getenv("PYEDB_USE_DOTNET", "1")):
+        from pyedb.dotnet.edb import Edb as app
+
+        return app(
+            edbpath=edbpath,
+            cellname=cellname,
+            isreadonly=isreadonly,
+            edbversion=edbversion,
+            isaedtowned=isaedtowned,
+            oproject=oproject,
+            student_version=student_version,
+            use_ppe=use_ppe,
+            technology_file=technology_file,
+        )
+    # TODO: Use EDB gRPC
+    else:
+        raise Exception("not implemented yet.")
+
+
+app_map = {"EDB": Edb}

pyedb/generic/filesystem.py

@@ -0,0 +1,150 @@
+import os
+import random
+import shutil
+import string
+
+
+def search_files(dirname, pattern="*"):
+    """Search for files inside a directory given a specific pattern.
+
+    Parameters
+    ----------
+    dirname : str
+    pattern :str, optional
+
+    Returns
+    -------
+    list
+    """
+    from pyedb.generic.general_methods import is_ironpython
+
+    if is_ironpython:
+        import glob
+
+        return list(glob.glob(os.path.join(dirname, pattern)))
+    else:
+        import pathlib
+
+        return [os.path.abspath(i) for i in pathlib.Path(dirname).glob(pattern)]
+
+
+def my_location():
+    """ """
+    return os.path.normpath(os.path.dirname(__file__))
+
+
+class Scratch:
+    """ """
+
+    @property
+    def path(self):
+        """ """
+        return self._scratch_path
+
+    @property
+    def is_empty(self):
+        """ """
+        return self._cleaned
+
+    def __init__(self, local_path, permission=0o777, volatile=False):
+        self._volatile = volatile
+        self._cleaned = True
+        char_set = string.ascii_uppercase + string.digits
+        self._scratch_path = os.path.normpath(os.path.join(local_path, "scratch" + "".join(random.sample(char_set, 6))))
+        if os.path.exists(self._scratch_path):
+            try:
+                self.remove()
+            except:
+                self._cleaned = False
+        if self._cleaned:
+            try:
+                os.mkdir(self.path)
+                os.chmod(self.path, permission)
+            except FileNotFoundError as fnf_error:  # Raise error if folder doesn't exist.
+                print(fnf_error)
+
+    def remove(self):
+        """ """
+        try:
+            # TODO check why on Anaconda 3.7 get errors with os.path.exists
+            shutil.rmtree(self._scratch_path, ignore_errors=True)
+        except:
+            pass
+
+    def copyfile(self, src_file, dst_filename=None):
+        """
+        Copy a file to the scratch directory. The target filename is optional.
+        If omitted, the target file name is identical to the source file name.
+
+        Parameters
+        ----------
+        src_file : str
+            Source file with fullpath.
+        dst_filename : str, optional
+            Destination filename with the extension. The default is ``None``,
+            in which case the destination file is given the same name as the
+            source file.
+
+
+        Returns
+        -------
+        dst_file : str
+            Full path and file name of the copied file.
+
+        """
+        if dst_filename:
+            dst_file = os.path.join(self.path, dst_filename)
+        else:
+            dst_file = os.path.join(self.path, os.path.basename(src_file))
+        if os.path.exists(dst_file):
+            try:
+                os.unlink(dst_file)
+            except OSError:  # pragma: no cover
+                pass
+        try:
+            shutil.copy2(src_file, dst_file)
+        except FileNotFoundError as fnf_error:
+            print(fnf_error)
+
+        return dst_file
+
+    def copyfolder(self, src_folder, destfolder):
+        """
+
+        Parameters
+        ----------
+        src_folder :
+
+        destfolder :
+
+
+        Returns
+        -------
+
+        """
+        from distutils.dir_util import copy_tree
+
+        copy_tree(src_folder, destfolder)
+        return True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, ex_type, ex_value, ex_traceback):
+        if ex_type or self._volatile:
+            self.remove()
+
+
+def get_json_files(start_folder):
+    """
+    Get the absolute path to all *.json files in start_folder.
+
+    Parameters
+    ----------
+    start_folder, str
+        Path to the folder where the json files are located.
+
+    Returns
+    -------
+    """
+    return [y for x in os.walk(start_folder) for y in search_files(x[0], "*.json")]