PyNerva 0.0.5__py3-none-any.whl

nervapy/loader.py

@@ -0,0 +1,188 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+import sys
+
+
+class Loader:
+    def __init__(self, code_size, data_size=0):
+        from nervapy.util import is_int
+
+        if not is_int(code_size):
+            raise TypeError("code size must be an integer")
+        if not is_int(data_size):
+            raise TypeError("data size must be an integer")
+        if code_size <= 0:
+            raise ValueError("code size must be positive")
+        if data_size < 0:
+            raise ValueError("data size must be non-negative")
+
+        import mmap
+
+        self.allocation_granularity = max(mmap.ALLOCATIONGRANULARITY, mmap.PAGESIZE)
+        self.code_address = None
+        self.code_size = self.allocation_size(code_size)
+        self.data_address = None
+        self.data_size = self.allocation_size(data_size)
+
+        self._release_memory = None
+
+        osname = sys.platform.lower()
+        if (
+            osname == "darwin"
+            or osname.startswith("linux")
+            or osname.startswith("freebsd")
+        ):
+            import ctypes
+
+            if osname == "darwin":
+                libc = ctypes.cdll.LoadLibrary("libc.dylib")
+            elif osname.startswith("freebsd"):
+                libc = ctypes.cdll.LoadLibrary("libc.so.7")
+            else:
+                libc = ctypes.cdll.LoadLibrary("libc.so.6")
+
+            # void* mmap(void* addr, size_t len, int prot, int flags, int fd, off_t offset)
+            mmap_function = libc.mmap
+            mmap_function.restype = ctypes.c_void_p
+            mmap_function.argtype = [
+                ctypes.c_void_p,
+                ctypes.c_size_t,
+                ctypes.c_int,
+                ctypes.c_int,
+                ctypes.c_int,
+                ctypes.c_size_t,
+            ]
+            # int munmap(void* addr, size_t len)
+            munmap_function = libc.munmap
+            munmap_function.restype = ctypes.c_int
+            munmap_function.argtype = [ctypes.c_void_p, ctypes.c_size_t]
+
+            def munmap(address, size):
+                munmap_result = munmap_function(ctypes.c_void_p(address), size)
+                assert munmap_result == 0
+
+            self._release_memory = lambda address_size: munmap(
+                address_size[0], address_size[1]
+            )
+
+            # Allocate code segment
+            code_address = mmap_function(
+                None,
+                self.code_size,
+                mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC,
+                mmap.MAP_ANON | mmap.MAP_PRIVATE,
+                -1,
+                0,
+            )
+            if code_address == -1:
+                raise OSError("Failed to allocate memory for code segment")
+            self.code_address = code_address
+
+            if self.data_size > 0:
+                # Allocate data segment
+                data_address = mmap_function(
+                    None,
+                    self.data_size,
+                    mmap.PROT_READ | mmap.PROT_WRITE,
+                    mmap.MAP_ANON | mmap.MAP_PRIVATE,
+                    -1,
+                    0,
+                )
+                if data_address == -1:
+                    raise OSError("Failed to allocate memory for data segment")
+                self.data_address = data_address
+        elif osname == "win32":
+            import ctypes
+
+            # From WinNT.h
+            PAGE_READWRITE = 0x04
+            PAGE_EXECUTE_READWRITE = 0x40
+            MEM_COMMIT = 0x1000
+            MEM_RESERVE = 0x2000
+            MEM_RELEASE = 0x8000
+
+            # LPVOID WINAPI VirtualAlloc(LPVOID address, SIZE_T size, DWORD allocationType, DWORD protect)
+            VirtualAlloc_function = ctypes.windll.kernel32.VirtualAlloc
+            VirtualAlloc_function.restype = ctypes.c_void_p
+            VirtualAlloc_function.argtypes = [
+                ctypes.c_void_p,
+                ctypes.c_size_t,
+                ctypes.c_ulong,
+                ctypes.c_ulong,
+            ]
+            # BOOL WINAPI VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD  dwFreeType)
+            VirtualFree_function = ctypes.windll.kernel32.VirtualFree
+            VirtualFree_function.restype = ctypes.c_int
+            VirtualFree_function.argtypes = [
+                ctypes.c_void_p,
+                ctypes.c_size_t,
+                ctypes.c_ulong,
+            ]
+
+            def VirtualFree(address, size):
+                VirtualFree_result = VirtualFree_function(address, 0, MEM_RELEASE)
+                assert VirtualFree_result != 0
+
+            self._release_memory = lambda address_size: VirtualFree(
+                address_size[0], address_size[1]
+            )
+
+            # Allocate code segment
+            code_address = VirtualAlloc_function(
+                None, self.code_size, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE
+            )
+            if not code_address:
+                raise OSError("Failed to allocate memory for code segment")
+            self.code_address = code_address
+
+            if self.data_size > 0:
+                # Allocate data segment
+                data_address = VirtualAlloc_function(
+                    None, self.data_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE
+                )
+                if not data_address:
+                    raise OSError("Failed to allocate memory for data segment")
+                self.data_address = data_address
+        elif osname == "nacl":
+            import dynacl
+
+            # Allocate code segment
+            self.allocation = dynacl.allocate(self.code_size, self.data_size)
+            self.code_address = self.allocation.code_address
+            self.data_address = self.allocation.data_address
+            self.copy_code = self._nacl_copy_code
+        else:
+            raise ValueError("Unknown host OS: " + osname)
+
+    def allocation_size(self, segment_size):
+        import nervapy.util
+
+        return nervapy.util.roundup(segment_size, self.allocation_granularity)
+
+    def copy_code(self, code_segment):
+        import ctypes
+
+        ctypes.memmove(
+            self.code_address, ctypes.c_char_p(bytes(code_segment)), len(code_segment)
+        )
+
+    def _nacl_copy_code(self, code_segment):
+        code_offset = 0
+        self.allocation.dyncode_create(code_segment, code_offset)
+
+    def copy_data(self, data_segment):
+        import ctypes
+
+        ctypes.memmove(
+            self.data_address, ctypes.c_char_p(bytes(data_segment)), len(data_segment)
+        )
+
+    def __del__(self):
+        if self._release_memory is not None:
+            if self.code_address is not None:
+                self._release_memory((self.code_address, self.code_size))
+                self.code_address = None
+            if self.data_address is not None:
+                self._release_memory((self.data_address, self.data_size))
+                self.data_address = None

nervapy/name.py

@@ -0,0 +1,159 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+import six
+
+
+class Name:
+    def __init__(self, name=None, prename=None):
+        assert name is None or isinstance(name, str)
+        assert prename is None or isinstance(prename, str)
+        assert (
+            name is None or prename is None
+        ), "Either name or prename, but not both, can be specified"
+        self.name = name
+        self.prename = prename
+
+    def __str__(self):
+        if self.name is not None:
+            return self.name
+        elif self.prename is not None:
+            return "<" + self.prename + ">"
+        else:
+            return "<?>"
+
+    def __repr__(self):
+        return str(self)
+
+    def __hash__(self):
+        return hash(self.name) ^ id(self)
+
+    def __eq__(self, other):
+        return isinstance(other, Name) and (self is other or self.name == other.name)
+
+    def __ne__(self, other):
+        return not isinstance(other, Name) or (
+            self is not other and self.name != other.name
+        )
+
+    @staticmethod
+    def check_name(name):
+        """Verifies that the name is appropriate for a symbol"""
+        if not isinstance(name, str):
+            raise TypeError("Invalid name %s: string required" % str(name))
+        import re
+
+        if not re.match("^[_a-zA-Z]\\w*$", name):
+            raise ValueError("Invalid name: " + name)
+        if name.startswith("__"):
+            raise ValueError(
+                "Invalid name %s: names starting with __ are reserved for PeachPy purposes"
+                % name
+            )
+
+
+class Namespace:
+    def __init__(self, scope_name):
+        assert scope_name is None or isinstance(scope_name, Name)
+        # Name of the namespace.
+        self.scope_name = scope_name
+        # Map from name string to either Name or Namespace object
+        self.names = dict()
+        # Map from prename string to a set of Name and Namespace objects
+        self.prenames = dict()
+
+    def __str__(self):
+        return str(self.scope_name)
+
+    def __hash__(self):
+        return hash(self.scope_name)
+
+    def __eq__(self, other):
+        return isinstance(other, Namespace) and self.scope_name == other.scope_name
+
+    def __ne__(self, other):
+        return not isinstance(other, Namespace) or self.scope_name != other.scope_name
+
+    def add_scoped_name(self, scoped_name):
+        assert isinstance(scoped_name, tuple)
+        scope_name, subscoped_name = scoped_name[0], scoped_name[1:]
+        assert isinstance(scope_name, Name)
+        scope = scope_name
+        if subscoped_name:
+            scope = Namespace(scope_name)
+            scope.add_scoped_name(subscoped_name)
+        if scope_name.name:
+            assert scope_name.prename is None
+            if scope_name.name in self.names:
+                if subscoped_name and isinstance(
+                    self.names[scope_name.name], Namespace
+                ):
+                    self.names[scope_name.name].add_scoped_name(subscoped_name)
+                else:
+                    raise ValueError("Name %s already exists" % scope_name.name)
+            else:
+                self.names[scope_name.name] = scope
+        else:
+            assert scope_name.name is None
+            self.prenames.setdefault(scope_name.prename, set())
+            if subscoped_name:
+                for subscope in iter(self.prenames[scope_name.prename]):
+                    if (
+                        isinstance(subscope, Namespace)
+                        and subscope.scope_name is scope_name
+                    ):
+                        subscope.add_scoped_name(subscoped_name)
+                        return
+            self.prenames[scope_name.prename].add(scope)
+
+    def assign_names(self):
+        # Step 1: assign names to symbols with prenames with no conflicts
+        for prename in six.iterkeys(self.prenames):
+            if prename is not None:
+                if len(self.prenames[prename]) == 1 and prename not in self.names:
+                    name_object = next(iter(self.prenames[prename]))
+                    self.names[prename] = name_object
+                    if isinstance(name_object, Namespace):
+                        name_object = name_object.scope_name
+                    name_object.name = prename
+
+        # Step 2: assign names to symbols with conflicting prenames
+        for prename, prename_objects in six.iteritems(self.prenames):
+            if prename is not None:
+                suffix = 0
+                suffixed_name = prename + str(suffix)
+                for name_object in iter(prename_objects):
+                    # Check that the name wasn't already assigned at Step 1
+                    if name_object.name is None:
+                        # Generate a non-conflicting name by appending a suffix
+                        while suffixed_name in self.names:
+                            suffix += 1
+                            suffixed_name = prename + str(suffix)
+                        self.names[suffixed_name] = name_object
+                        if isinstance(name_object, Namespace):
+                            name_object = name_object.scope_name
+                        name_object.name = suffixed_name
+
+        # Step 3: assign names to symbols without prenames
+        if None in self.prenames:
+            unnamed_objects = self.prenames[None]
+            suffix = 0
+            suffixed_name = "__local" + str(suffix)
+            for name_object in iter(unnamed_objects):
+                # Generate a non-conflicting name by appending a suffix
+                while suffixed_name in self.names:
+                    suffix += 1
+                    suffixed_name = "__local" + str(suffix)
+                self.names[suffixed_name] = name_object
+                if isinstance(name_object, Namespace):
+                    name_object = name_object.scope_name
+                name_object.name = suffixed_name
+        pass
+
+    @property
+    def name(self):
+        return self.scope_name.name
+
+    @property
+    def prename(self):
+        return self.scope_name.prename

nervapy/parse.py

@@ -0,0 +1,52 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+
+def parse_assigned_variable_name(stack_frames, constructor_name):
+    """Analyses the provided stack frames and parses Python assignment expressions like
+         some.namespace.variable_name   =   some.module.name.`constructor_name`(...)
+    from the caller's call site and returns the name of the variable being assigned as a string.
+    If the assignment expression is not found, returns None.
+    """
+    if isinstance(stack_frames, list) and len(stack_frames) > 1:
+        parent_stack_frame = stack_frames[1]
+        if isinstance(parent_stack_frame, tuple) and len(parent_stack_frame) == 6:
+            _, _, _, _, source_lines, _ = parent_stack_frame
+            if isinstance(source_lines, list) and source_lines:
+                source_line = source_lines[0]
+                if source_line:
+                    import re
+
+                    assignment_regexp = (
+                        r"(?:\w+\.)*(\w+)\s*=\s*(?:\w+\.)*"
+                        + re.escape(constructor_name)
+                        + r"\(.*\)"
+                    )
+                    match = re.match(assignment_regexp, source_line.strip())
+                    if match:
+                        return match.group(1)
+
+
+def parse_with_variable_name(stack_frames, constructor_name):
+    """Analyses the provided stack frames and parses Python with expressions like
+         with `constructor_name`(...) as variable_name:
+    from the caller's call site and returns the name of the variable named in the statement as a string.
+    If a with statement is not found, returns None.
+    """
+    if isinstance(stack_frames, list) and len(stack_frames) > 1:
+        parent_stack_frame = stack_frames[1]
+        if isinstance(parent_stack_frame, tuple) and len(parent_stack_frame) == 6:
+            _, _, _, _, source_lines, _ = parent_stack_frame
+            if isinstance(source_lines, list) and source_lines:
+                source_line = source_lines[0]
+                if source_line:
+                    import re
+
+                    with_regexp = (
+                        r"with\s+(?:\w+\.)*"
+                        + re.escape(constructor_name)
+                        + r"\(.*\)\s+as\s+([_a-zA-Z]\w*)\s*:"
+                    )
+                    match = re.match(with_regexp, source_line.strip())
+                    if match:
+                        return match.group(1)

nervapy/stream.py

@@ -0,0 +1,58 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+active_stream = None
+
+
+class InstructionStream(object):
+    def __init__(self):
+        self.instructions = list()
+        self.previous_stream = None
+
+    def __enter__(self):
+        global active_stream
+        self.previous_stream = active_stream
+        active_stream = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        global active_stream
+        active_stream = self.previous_stream
+        self.previous_stream = None
+
+    def __iter__(self):
+        return iter(self.instructions)
+
+    def __len__(self):
+        return len(self.instructions)
+
+    def __getitem__(self, i):
+        try:
+            return self.instructions[i]
+        except IndexError:
+            return None
+
+    def add_instruction(self, instruction):
+        if instruction is not None:
+            self.instructions.append(instruction)
+
+    def issue(self, count=1):
+        for i in range(count):
+            if self.instructions:
+                active_stream.add_instruction(self.instructions.pop(0))
+
+
+class NullStream:
+    def __init__(self):
+        self.previous_stream = None
+
+    def __enter__(self):
+        global active_stream
+        self.previous_stream = active_stream
+        active_stream = None
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        global active_stream
+        active_stream = self.previous_stream
+        self.previous_stream = None

nervapy/util.py

@@ -0,0 +1,126 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+import six
+
+
+def int_size(n):
+    assert is_int64(n)
+    if is_int8(n):
+        return 1
+    elif is_int16(n):
+        return 2
+    elif is_int32(n):
+        return 4
+    else:
+        return 8
+
+
+def is_int(n):
+    return isinstance(n, six.integer_types)
+
+
+def is_int64(n):
+    return (
+        isinstance(n, six.integer_types)
+        and -9223372036854775808 <= n <= 18446744073709551615
+    )
+
+
+def is_sint64(n):
+    return (
+        isinstance(n, six.integer_types)
+        and -9223372036854775808 <= n <= 9223372036854775807
+    )
+
+
+def is_uint64(n):
+    return isinstance(n, six.integer_types) and 0 <= n <= 18446744073709551615
+
+
+def is_int32(n):
+    return isinstance(n, six.integer_types) and -2147483648 <= n <= 4294967295
+
+
+def is_sint32(n):
+    return isinstance(n, six.integer_types) and -2147483648 <= n <= 2147483647
+
+
+def is_uint32(n):
+    return isinstance(n, six.integer_types) and 0 <= n <= 4294967295
+
+
+def is_int16(n):
+    return isinstance(n, six.integer_types) and -32768 <= n <= 65535
+
+
+def is_sint16(n):
+    return isinstance(n, six.integer_types) and -32768 <= n <= 32767
+
+
+def is_uint16(n):
+    return isinstance(n, six.integer_types) and 0 <= n <= 65535
+
+
+def is_int8(n):
+    return isinstance(n, six.integer_types) and -128 <= n <= 255
+
+
+def is_uint8(n):
+    return isinstance(n, six.integer_types) and 0 <= n <= 255
+
+
+def is_sint8(n):
+    return isinstance(n, six.integer_types) and -128 <= n <= 127
+
+
+def roundup(n, q):
+    import math
+
+    return int(math.ceil(float(n) / float(q)) * q)
+
+
+def ilog2(n):
+    if n & (n - 1) != 0:
+        raise ValueError("%u is not an power of 2" % n)
+    if n == 0:
+        return 0
+    else:
+        l = 0
+        while n != 1:
+            l += 1
+            n >>= 1
+        return l
+
+
+def unique(seq):
+    seq_values = set()
+    unique_seq = []
+    for value in seq:
+        if value not in seq_values:
+            seq_values.add(value)
+            unique_seq.append(value)
+    return unique_seq
+
+
+def append_unique(value, sequence=None):
+    if sequence is None:
+        return [value]
+    else:
+        if value not in sequence:
+            sequence.append(value)
+        return sequence
+
+
+def pairwise(iterable):
+    import itertools
+
+    a, b = itertools.tee(iterable)
+    next(b, None)
+    return itertools.izip(a, b)
+
+
+def diff(sequence):
+    import operator
+
+    return map(operator.__sub__, pairwise(sequence))