Instruction:
Can you create a Python 3 function that
checks that we don t create a device that already exists and that we don t have any duplicate interfaces.

Response:
def _validate_duplicates(self):
        """
        Ensure we're not creating a device that already exists
        Runs only when the DeviceConnector object is created, not when is updated
        """
        # if connector is being created right now
        if not self.id:
            duplicates = []
            self.netengine_dict = self.netengine.to_dict()
            # loop over interfaces and check mac address
            for interface in self.netengine_dict['interfaces']:
                # avoid checking twice for the same interface (often ifconfig returns duplicates)
                if interface['mac_address'] in duplicates:
                    continue
                # check in DB
                if Interface.objects.filter(mac__iexact=interface['mac_address']).count() > 0:
                    duplicates.append(interface['mac_address'])

            # if we have duplicates raise validation error
            if len(duplicates) > 0:
                mac_address_string = ', '.join(duplicates)
                raise ValidationError(_('interfaces with the following mac addresses already exist: %s') % mac_address_string)


Instruction:
Make a summary of the following Python 3 code
def _get_netengine_arguments(self, required=False):
        # inspect netengine class
        backend_class = self._get_netengine_backend()
        argspec = inspect.getargspec(backend_class.__init__)
        # store args
        args = argspec.args
        # remove known arguments
        for argument_name in ['self', 'host', 'port']:
            args.remove(argument_name)

        if required:
            # list of default values
            default_values = list(argspec.defaults)
            # always remove last default value, which is port number
            default_values = default_values[0:-1]

            # remove an amount of arguments equals to number of default values, starting from right
            args = args[0:len(args)-len(default_values)]

        return args

Response: returns list of available config params


Instruction:
Make a summary of the following Python 3 code
def _get_netengine_backend(self):
        # extract backend class name, eg: AirOS or OpenWRT
        backend_class_name = self.backend.split('.')[-1]
        # convert to lowercase to get the path
        backend_path = self.backend.lower()
        # import module by its path
        module = import_module(backend_path)
        # get netengine backend class
        BackendClass = getattr(module, backend_class_name)

        return BackendClass

Response:
returns the netengine backend specified in self. backend
        for internal use only


Instruction:
Can you implement a function in Python 3 that
builds a python dictionary representing the arguments that will be passed to netengine backend for internal use only

Response:
def _build_netengine_arguments(self):
        """
        returns a python dictionary representing arguments
        that will be passed to a netengine backend
        for internal use only
        """
        arguments = {
            "host": self.host
        }

        if self.config is not None:
            for key, value in self.config.iteritems():
                arguments[key] = value

        if self.port:
            arguments["port"] = self.port

        return arguments


Instruction:
Write a Python 3 script to
create a new device object based on the current state of the node.

Response:
def __create_device(self):
        """
        creates device, internal use only
        """
        # retrieve netengine dictionary from memory or from network
        device_dict = getattr(self, 'netengine_dict', self.netengine.to_dict())
        device = Device()
        device.node_id = self.node_id
        device.name = device_dict['name']
        device.type = device_dict['type']
        device.status = DEVICE_STATUS.get('reachable')
        device.os = device_dict['os']
        device.os_version = device_dict['os_version']
        # this is the first time the device is seen by the system because we are just adding it
        device.first_seen = now()
        # and is also the latest
        device.last_seen = now()
        device.full_clean()
        device.save()

        # add routing protocols
        for routing_protocol in device_dict['routing_protocols']:
            # retrieve routing protocol from DB
            try:
                rp = RoutingProtocol.objects.filter(
                    name__iexact=routing_protocol['name'],
                    version__iexact=routing_protocol['version']
                )[0]
            # create if doesn't exist yet
            except IndexError:
                rp = RoutingProtocol(
                    name=routing_protocol['name'],
                    version=routing_protocol['version']
                )
                rp.full_clean()
                rp.save()
            # add to device
            device.routing_protocols.add(rp)

        for interface in device_dict['interfaces']:
            interface_object = False
            vap_object = False
            # create interface depending on type
            if interface['type'] == 'ethernet':
                interface_object = Ethernet(**{
                    'device': device,
                    'name': interface['name'],
                    'mac': interface['mac_address'],
                    'mtu': interface['mtu'],
                    'standard': interface['standard'],
                    'duplex': interface['duplex'],
                    'tx_rate': interface['tx_rate'],
                    'rx_rate': interface['rx_rate']
                })
            elif interface['type'] == 'wireless':
                interface_object = Wireless(**{
                    'device': device,
                    'name': interface['name'],
                    'mac': interface['mac_address'],
                    'mtu': interface['mtu'],
                    'mode': interface['mode'],
                    'standard': interface['standard'],
                    'channel': interface['channel'],
                    'channel_width': interface['channel_width'],
                    'output_power': interface['output_power'],
                    'dbm': interface['dbm'],
                    'noise': interface['noise'],
                    'tx_rate': interface['tx_rate'],
                    'rx_rate': interface['rx_rate']
                })

                for vap in interface['vap']:
                    vap_object = Vap(
                        essid=vap['essid'],
                        bssid=vap['bssid'],
                        encryption=vap['encryption']
                    )

            if interface_object:
                interface_object.full_clean()
                interface_object.save()

                if vap_object:
                    vap_object.interface = interface_object
                    vap_object.full_clean()
                    vap_object.save()

                for ip in interface['ip']:
                    ip_object = Ip(**{
                        'interface': interface_object,
                        'address': ip['address'],
                    })
                    ip_object.full_clean()
                    ip_object.save()

        if HARDWARE_INSTALLED:
            # try getting device model from db
            try:
                device_model = DeviceModel.objects.filter(name__iexact=device_dict['model'])[0]
            # if it does not exist create it
            except IndexError as e:
                # try getting manufacturer from DB
                try:
                    manufacturer = Manufacturer.objects.filter(name__iexact=device_dict['manufacturer'])[0]
                # or create
                except IndexError as e:
                    manufacturer = Manufacturer(name=device_dict['manufacturer'])
                    manufacturer.full_clean()
                    manufacturer.save()

                device_model = DeviceModel(
                    manufacturer=manufacturer,
                    name=device_dict['model']
                )
                device_model.ram = device_dict['RAM_total']

            device_model.full_clean()
            device_model.save()

            # create relation between device model and device
            rel = DeviceToModelRel(device=device, model=device_model)
            rel.full_clean()
            rel.save()

        return device


Instruction:
Write a Python 3 script to
cache view response by group.

Response:
def cache_by_group(view_instance, view_method, request, args, kwargs):
    """
    Cache view response by media type and user group.
    The cache_key is constructed this way: "{view_name:path.group.media_type}"
    EG: "MenuList:/api/v1/menu/.public.application/json"
    Possible groups are:
        * public
        * superuser
        * the rest are retrieved from DB (registered, community, trusted are the default ones)
    """
    if request.user.is_anonymous():
        group = 'public'
    elif request.user.is_superuser:
        group = 'superuser'
    else:
        try:
            group = request.user.groups.all().order_by('-id').first().name
        except IndexError:
            group = 'public'

    key = '%s:%s.%s.%s' % (
        view_instance.__class__.__name__,
        request.META['PATH_INFO'],
        group,
        request.accepted_media_type
    )

    return key


Instruction:
Write a Python 3 function that can
generate a model class based on the provided JSON schema.

Response:
def model_factory(schema, resolver=None, base_class=model.Model, name=None):
    """Generate a model class based on the provided JSON Schema

    :param schema: dict representing valid JSON schema
    :param name: A name to give the class, if `name` is not in `schema`
    """
    schema = copy.deepcopy(schema)
    resolver = resolver

    class Model(base_class):
        def __init__(self, *args, **kwargs):
            self.__dict__['schema'] = schema
            self.__dict__['resolver'] = resolver
            base_class.__init__(self, *args, **kwargs)

    if resolver is not None:
        Model.resolver = resolver

    if name is not None:
        Model.__name__ = name
    elif 'name' in schema:
        Model.__name__ = str(schema['name'])
    return Model


Instruction:
Write a Python 3 script to
return a jsonpatch object representing the delta

Response:
def patch(self):
        """Return a jsonpatch object representing the delta"""
        original = self.__dict__['__original__']
        return jsonpatch.make_patch(original, dict(self)).to_string()


Instruction:
Make a summary of the following Python 3 code
def changes(self):
        deprecation_msg = 'Model.changes will be removed in warlock v2'
        warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
        return copy.deepcopy(self.__dict__['changes'])

Response: A list of changes in this object.


Instruction:
How would you explain what the following Python 3 function does
def validate(self, obj):
        try:
            if self.resolver is not None:
                jsonschema.validate(obj, self.schema, resolver=self.resolver)
            else:
                jsonschema.validate(obj, self.schema)
        except jsonschema.ValidationError as exc:
            raise exceptions.ValidationError(str(exc))

Response: Apply a JSON schema to an object


Instruction:
Can you tell what is the following Python 3 function doing
def isSupportedContent(cls, fileContent):
        magic = bytearray(fileContent)[:4]
        return magic == p('>I', 0xfeedface) or magic == p('>I', 0xfeedfacf) or magic == p('<I', 0xfeedface) or magic == p('<I', 0xfeedfacf)

Response: Returns if the file content is valid for this filetype


Instruction:
Write a Python 3 script for
returning the OatHeaderData object from the data

Response:
def _parseOatHeader(self, data):
        """Returns the OatHeader"""
        header = OatHeader.from_buffer(data)
        if header.magic != b'oat\n':
            raise BinaryError('No valid OAT file')

        key_value_store_bytes = (c_ubyte * header.keyValueStoreSize).from_buffer(data, sizeof(OatHeader))
        key_value_store = self.__parseKeyValueStore(key_value_store_bytes)

        return OatHeaderData(header=header, keyValueStoreRaw=key_value_store_bytes, keyValueStore=key_value_store)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def __parseKeyValueStore(self, data):
        offset = 0
        key_value_store = {}
        while offset != len(data):
            key = get_str(data, offset)
            offset += len(key)+1

            value = get_str(data, offset)
            offset += len(value)+1

            key_value_store[key] = value

        return key_value_store

Response: Parses the key value store from the data


Instruction:
Can you tell what is the following Python 3 function doing
def to_raw_address(addr, section):
        return addr - section.header.VirtualAddress + section.header.PointerToRawData

Response: Converts the addr from a rva to a pointer to raw data in the file


Instruction:
Write a Python 3 script to
return the class which holds the suitable classes for the loaded file

Response:
def _getSuitableClasses(self, data, imageDosHeader):
        """Returns the class which holds the suitable classes for the loaded file"""
        classes = None
        machine = IMAGE_FILE_MACHINE[c_ushort.from_buffer(data,imageDosHeader.header.e_lfanew+4).value]

        if machine == IMAGE_FILE_MACHINE.I386:
            classes = PE32
        elif machine == IMAGE_FILE_MACHINE.AMD64:
            classes = PE64

        return classes


Instruction:
Write a Python 3 script for
returning the ImageDosHeader data

Response:
def _parseImageDosHeader(self, data):
        """Returns the ImageDosHeader"""
        ioh = IMAGE_DOS_HEADER.from_buffer(data)
        if ioh.e_magic != b'MZ':
            raise BinaryError('No valid PE/COFF file')

        return ImageDosHeaderData(header=ioh)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _parseImageNtHeaders(self, data, imageDosHeader):
        inth = self._classes.IMAGE_NT_HEADERS.from_buffer(data, imageDosHeader.header.e_lfanew)

        if inth.Signature != b'PE':
            raise BinaryError('No valid PE/COFF file')

        return ImageNtHeaderData(header=inth)

Response: Returns the ImageNtHeaders object from the data.


Instruction:
Can you generate the documentation for the following Python 3 function
def _parseSections(self, data, imageDosHeader, imageNtHeaders, parse_header_only=False):
        sections = []

        optional_header_offset = imageDosHeader.header.e_lfanew + 4 + sizeof(IMAGE_FILE_HEADER)
        offset = optional_header_offset + imageNtHeaders.header.FileHeader.SizeOfOptionalHeader  # start reading behind the dos- and ntheaders

        image_section_header_size = sizeof(IMAGE_SECTION_HEADER)

        for sectionNo in range(imageNtHeaders.header.FileHeader.NumberOfSections):
            ishdr = IMAGE_SECTION_HEADER.from_buffer(data, offset)

            if parse_header_only:
                raw = None
                bytes_ = bytearray()
            else:
                size = ishdr.SizeOfRawData
                raw = (c_ubyte * size).from_buffer(data, ishdr.PointerToRawData)
                bytes_ = bytearray(raw)

            sections.append(SectionData(header=ishdr, name=ishdr.Name.decode('ASCII', errors='ignore'), bytes=bytes_, raw=raw))

            offset += image_section_header_size

        return sections

Response: Parses the sections in the memory and returns a list of them


Instruction:
Create a Python 3 function for
returning the section which contains the data of the DataDirectory entry.

Response:
def _getSectionForDataDirectoryEntry(self, data_directory_entry, sections):
        """Returns the section which contains the data of DataDirectory"""
        for section in sections:
            if data_directory_entry.VirtualAddress >= section.header.VirtualAddress and \
            data_directory_entry.VirtualAddress < section.header.VirtualAddress + section.header.SizeOfRawData :

                return section


Instruction:
Here you have a function in Python 3, explain what it does
def _parseDataDirectory(self, data, sections, imageNtHeaders):
        data_directory_data_list = [None for i in range(15)]

        # parse DataDirectory[Export]
        export_data_directory = imageNtHeaders.header.OptionalHeader.DataDirectory[ImageDirectoryEntry.EXPORT]
        export_section = self._getSectionForDataDirectoryEntry(export_data_directory, sections)
        export_data_directory_data = self._parseDataDirectoryExport(data, export_data_directory, export_section)
        data_directory_data_list[ImageDirectoryEntry.EXPORT] = export_data_directory_data

        # parse DataDirectory[Import]
        import_data_directory = imageNtHeaders.header.OptionalHeader.DataDirectory[ImageDirectoryEntry.IMPORT]
        import_section = self._getSectionForDataDirectoryEntry(import_data_directory, sections)
        import_data_directory_data = self._parseDataDirectoryImport(import_data_directory, import_section)
        data_directory_data_list[ImageDirectoryEntry.IMPORT] = import_data_directory_data

        # parse DataDirectory[LOAD_CONFIG]
        loadconfig_data_directory = imageNtHeaders.header.OptionalHeader.DataDirectory[ImageDirectoryEntry.LOAD_CONFIG]
        loadconfig_section = self._getSectionForDataDirectoryEntry(loadconfig_data_directory, sections)
        loadconfig_data = self._parseLoadConfig(loadconfig_data_directory, loadconfig_section)
        data_directory_data_list[ImageDirectoryEntry.LOAD_CONFIG] = loadconfig_data

        return data_directory_data_list

Response: Parses the entries of the DataDirectory and returns a list of the content


Instruction:
How would you implement a function in Python 3 that
parses the EmportDataDirectory and returns an instance of ExportDirectoryData

Response:
def _parseDataDirectoryExport(self, data, dataDirectoryEntry, exportSection):
        """Parses the EmportDataDirectory and returns an instance of ExportDirectoryData"""
        if not exportSection:
            return
        functions = []
        export_directory = IMAGE_EXPORT_DIRECTORY.from_buffer(exportSection.raw, to_offset(dataDirectoryEntry.VirtualAddress, exportSection))
        offset = to_offset(export_directory.Name, exportSection)

        checkOffset(offset, exportSection)
        name = get_str(exportSection.raw, offset)

        offsetOfNames = to_offset(export_directory.AddressOfNames, exportSection)
        offsetOfAddress = to_offset(export_directory.AddressOfFunctions, exportSection)
        offsetOfNameOrdinals = to_offset(export_directory.AddressOfNameOrdinals, exportSection)
        for i in range(export_directory.NumberOfNames):
            name_address = c_uint.from_buffer(exportSection.raw, offsetOfNames).value
            name_offset = to_offset(name_address, exportSection)

            checkOffset(name_offset, exportSection)
            func_name = get_str(exportSection.raw, name_offset)
            ordinal = c_ushort.from_buffer(exportSection.raw, offsetOfNameOrdinals).value
            func_addr = c_uint.from_buffer(exportSection.raw, offsetOfAddress).value

            offsetOfNames += 4
            offsetOfAddress += 4
            offsetOfNameOrdinals += 2
            functions.append(FunctionData(name=func_name, rva=func_addr, ordinal=ordinal))

        return ExportDirectoryData(header=export_directory, name=name, functions=functions)


Instruction:
How would you code a function in Python 3 to
parse the ImportDataDirectory and returns a list of ImportDescriptorData s.

Response:
def _parseDataDirectoryImport(self, dataDirectoryEntry, importSection):
        """Parses the ImportDataDirectory and returns a list of ImportDescriptorData"""
        if not importSection:
            return

        raw_bytes = (c_ubyte * dataDirectoryEntry.Size).from_buffer(importSection.raw, to_offset(dataDirectoryEntry.VirtualAddress, importSection))
        offset = 0
        import_descriptors = []
        while True:
            import_descriptor = IMAGE_IMPORT_DESCRIPTOR.from_buffer(raw_bytes, offset)

            if import_descriptor.OriginalFirstThunk == 0:
                break
            else:
                nameOffset = to_offset(import_descriptor.Name, importSection)

                checkOffset(nameOffset, importSection)
                dllName = get_str(importSection.raw, nameOffset)

                import_name_table =  self.__parseThunks(import_descriptor.OriginalFirstThunk, importSection)
                import_address_table =  self.__parseThunks(import_descriptor.FirstThunk, importSection)

                import_descriptors.append(ImportDescriptorData(header=import_descriptor, dllName=dllName, importNameTable=import_name_table, importAddressTable=import_address_table))
            offset += sizeof(IMAGE_IMPORT_DESCRIPTOR)
        return import_descriptors


Instruction:
Write a Python 3 function for
parsing the thunks and returns a list of ThunkData objects

Response:
def __parseThunks(self, thunkRVA, importSection):
        """Parses the thunks and returns a list"""
        offset = to_offset(thunkRVA, importSection)
        table_offset = 0
        thunks = []
        while True:
            thunk = IMAGE_THUNK_DATA.from_buffer(importSection.raw, offset)
            offset += sizeof(IMAGE_THUNK_DATA)
            if thunk.Ordinal == 0:
                break
            thunkData = ThunkData(header=thunk, rva=table_offset+thunkRVA,ordinal=None, importByName=None)
            if to_offset(thunk.AddressOfData, importSection) > 0 and to_offset(thunk.AddressOfData, importSection) < len(self._bytes):
                self.__parseThunkData(thunkData, importSection)
            thunks.append(thunkData)
            table_offset += 4
        return thunks


Instruction:
Given the following Python 3 function, write the documentation
def __parseThunkData(self, thunk,importSection):
        offset = to_offset(thunk.header.AddressOfData, importSection)
        if 0xf0000000 & thunk.header.AddressOfData == 0x80000000:
            thunk.ordinal = thunk.header.AddressOfData & 0x0fffffff
        else:
            ibn = IMAGE_IMPORT_BY_NAME.from_buffer(importSection.raw, offset)

            checkOffset(offset+2, importSection)
            name = get_str(importSection.raw, offset+2)
            thunk.importByName = ImportByNameData(header=ibn, hint=ibn.Hint, name=name)

Response: Parses the data of a thunk and sets the data


Instruction:
Create a Python 3 function for
returning a void pointer to the data

Response:
def get_ptr(data, offset=None, ptr_type=ctypes.c_void_p):
    """Returns a void pointer to the data"""
    ptr = ctypes.cast(ctypes.pointer(data), ctypes.c_void_p)

    if offset:
        ptr = ctypes.c_void_p(ptr.value + offset)

    if ptr_type != ctypes.c_void_p:
        ptr = ctypes.cast(ptr, ptr_type)

    return ptr


Instruction:
Implement a function in Python 3 to
return a c_ubyte_array filled with the given data of a bytearray or bytes

Response:
def to_ubyte_array(barray):
    """Returns a c_ubyte_array filled with the given data of a bytearray or bytes"""
    bs = (ctypes.c_ubyte * len(barray))()
    pack_into('%ds' % len(barray), bs, 0, barray)

    return bs


Instruction:
Can you write a function in Python 3 where it
reads the file and returns the bytes of the file.

Response:
def _readFile(self, fileName):
        """
        Returns the bytes of the file.
        """
        with open(fileName, 'rb') as binFile:
            b = binFile.read()
            return to_ubyte_array(b)


Instruction:
Implement a Python 3 function for
returning the class which holds the suitable classes for the loaded file

Response:
def _getSuitableClasses(self, data):
        """Returns the class which holds the suitable classes for the loaded file"""
        classes = None
        if data[EI.CLASS] == ELFCLASS.BITS_32:
            if data[EI.DATA] == ELFDATA.LSB:
                classes = LSB_32
            elif data[EI.DATA] == ELFDATA.MSB:
                classes = MSB_32

        elif data[EI.CLASS] == ELFCLASS.BITS_64:
            if data[EI.DATA] == ELFDATA.LSB:
                classes = LSB_64
            elif data[EI.DATA] == ELFDATA.MSB:
                classes = MSB_64

        return classes


Instruction:
Make a summary of the following Python 3 code
def _parseElfHeader(self, data):
        ehdr = self.__classes.EHDR.from_buffer(data)
        return EhdrData(header=ehdr)

Response: Returns the elf header


Instruction:
Can you generate the documentation for the following Python 3 function
def _parseSegments(self, data, elfHeader):
        offset = elfHeader.header.e_phoff
        segments = []
        for i in range(elfHeader.header.e_phnum):
            phdr = self.__classes.PHDR.from_buffer(data, offset)
            segment_bytes = (c_ubyte * phdr.p_filesz).from_buffer(data, phdr.p_offset)

            phdrData = PhdrData(header=phdr, raw=segment_bytes, bytes=bytearray(segment_bytes), type=PT[phdr.p_type], vaddr=phdr.p_vaddr, offset=phdr.p_offset)
            segments.append(phdrData)

            offset += elfHeader.header.e_phentsize

        return segments

Response: Parse the segments from the data.


Instruction:
Can you generate the documentation for the following Python 3 function
def _parseSections(self, data, elfHeader):
        offset = elfHeader.header.e_shoff
        shdrs = []
        for i in range(elfHeader.header.e_shnum):
            shdr = self.__classes.SHDR.from_buffer(data, offset)
            section_bytes = None
            ba_section_bytes = None
            if shdr.sh_type != SHT.NOBITS:
                section_bytes = (c_ubyte * shdr.sh_size).from_buffer(data, shdr.sh_offset)
                ba_section_bytes = bytearray(section_bytes)
            shdrs.append(ShdrData(name=None,header=shdr, raw=section_bytes, bytes=ba_section_bytes))
            offset += elfHeader.header.e_shentsize

        if elfHeader.header.e_shstrndx != SHN.UNDEF:
            strtab = shdrs[elfHeader.header.e_shstrndx]
            strtab_offset = strtab.header.sh_offset

            for section in shdrs:
                section.name = get_str(strtab.raw, section.header.sh_name)

        return shdrs

Response: Returns a list of sections


Instruction:
Can you tell what is the following Python 3 function doing
def _parseSymbols(self, sections):
        for section in sections:
            strtab = sections[section.header.sh_link]
            if section.header.sh_type in (int(SHT.DYNSYM), int(SHT.SYMTAB)):
                section.symbols = self.__parseSymbolEntriesForSection(section, strtab)

Response: Sets a list of symbols in each DYNSYM and SYMTAB section


Instruction:
Explain what the following Python 3 code does
def _parseRelocations(self, sections):
        for section in sections:
            if section.header.sh_link != SHN.UNDEF and section.header.sh_type in (SHT.REL, SHT.RELA):
                symbols = sections[section.header.sh_link].symbols
                relocations = self.__parseRelocationEntries(section, symbols)
                section.relocations = relocations

Response: Parses the relocations and adds those to the section


Instruction:
Implement a function in Python 3 to
run the model forward yielding to user code at specified intervals.

Response:
def run_with_snapshots(self, tsnapstart=0., tsnapint=432000.):
        """Run the model forward, yielding to user code at specified intervals.

        Parameters
        ----------

        tsnapstart : int
            The timestep at which to begin yielding.
        tstapint : int
            The interval at which to yield.
        """

        tsnapints = np.ceil(tsnapint/self.dt)

        while(self.t < self.tmax):
            self._step_forward()
            if self.t>=tsnapstart and (self.tc%tsnapints)==0:
                yield self.t
        return


Instruction:
Write a Python 3 function for
calculating the vertical modes of the standard matrix S.

Response:
def vertical_modes(self):
        """ Calculate standard vertical modes. Simply
            the eigenvectors of the stretching matrix S """

        evals,evecs = np.linalg.eig(-self.S)

        asort = evals.argsort()

        # deformation wavenumbers and radii
        self.kdi2 = evals[asort]
        self.radii = np.zeros_like(self.kdi2)
        self.radii[0] = self.g*self.H/np.abs(self.f) # barotropic def. radius
        self.radii[1:] = 1./np.sqrt(self.kdi2[1:])

        # eigenstructure
        self.pmodes = evecs[:,asort]

        # normalize to have unit L2-norm
        Ai = (self.H / (self.Hi[:,np.newaxis]*(self.pmodes**2)).sum(axis=0))**0.5
        self.pmodes = Ai[np.newaxis,:]*self.pmodes


Instruction:
Can you generate the documentation for the following Python 3 function
def modal_projection(self,p,forward=True):

        if forward:
            pt = np.linalg.solve(self.pmodes[np.newaxis,np.newaxis],p.T).T
        else:
            pt = np.einsum("ik,k...->i...",self.pmodes,p)

        return pt

Response:
Performs a field p into modal amplitudes pn
                using the basis [ pmodes ]. The inverse
                transform calculates p from pn.


Instruction:
Explain what the following Python 3 code does
def _initialize_background(self):

        # background vel.
        if len(np.shape(self.U)) == 0:
          self.U = (self.U * np.ones((self.ny)))
        print(np.shape(self.U))
        self.set_U(self.U)

        # the meridional PV gradients in each layer
        self.Qy = (self.beta + np.gradient(np.gradient(self.U, self.dy), self.dy))[np.newaxis,...]

        # complex versions, multiplied by k, speeds up computations to pre-compute
        self.ikQy = np.expand_dims(self.Qy, axis=2) *  1j * self.k

        self.ilQx = 0.

Response: Set up background state.


Instruction:
Can you tell what is the following Python 3 function doing
def _initialize_inversion_matrix(self):
        # The sqg model is diagonal. The inversion is simply qh = -kappa**2 ph
        self.a = np.asarray(self.Nb*np.sqrt(self.wv2i))[np.newaxis, np.newaxis, :, :]

Response: initialize the inversion matrix


Instruction:
Can you tell what is the following Python 3 function doing
def set_U(self, U):
        self.Ubg = np.asarray(U)[np.newaxis,...]

Response: Set background zonal flow


Instruction:
Make a summary of the following Python 3 code
def step_forward_with_function(self, uv0fun, uv1fun, dt):

        dx, dy = self._rk4_integrate(self.x, self.y, uv0fun, uv1fun, dt)
        self.x = self._wrap_x(self.x + dx)
        self.y = self._wrap_y(self.y + dy)

Response: Advance particles using a function to determine u and v.


Instruction:
Create a Python 3 function for
integrating positions x y using velocity functions uv0fun uv1fun. Returns dx dy the displacements.

Response:
def _rk4_integrate(self, x, y, uv0fun, uv1fun, dt):
        """Integrates positions x, y using velocity functions
           uv0fun, uv1fun. Returns dx and dy, the displacements."""
        u0, v0 = uv0fun(x, y)
        k1u = dt*u0
        k1v = dt*v0
        x11 = self._wrap_x(x + 0.5*k1u)
        y11 = self._wrap_y(y + 0.5*k1v)
        u11, v11 = uv1fun(x11, y11)
        k2u = dt*u11
        k2v = dt*v11
        x12 = self._wrap_x(x + 0.5*k2u)
        y12 = self._wrap_y(y + 0.5*k2v)
        u12, v12 = uv1fun(x12, y12)
        k3u = dt*u12
        k3v = dt*v12
        x13 = self._wrap_x(x + k3u)
        y13 = self._wrap_y(y + k3v)
        u13, v13 = uv1fun(x13, y13)
        k4u = dt*u13
        k4v = dt*v13

        # update
        dx = 6**-1*(k1u + 2*k2u + 2*k3u + k4u)
        dy = 6**-1*(k1v + 2*k2v + 2*k3v + k4v)
        return dx, dy


Instruction:
Here you have a function in Python 3, explain what it does
def _distance(self, x0, y0, x1, y1):
        dx = x1-x0
        dy = y1-y0
        # roll displacements across the borders
        if self.pix:
            dx[ dx > self.Lx/2 ] -= self.Lx
            dx[ dx < -self.Lx/2 ] += self.Lx
        if self.piy:
            dy[ dy > self.Ly/2 ] -= self.Ly
            dy[ dy < -self.Ly/2 ] += self.Ly
        return dx, dy

Response: Utitlity function to compute distance between points.


Instruction:
Can you generate the documentation for the following Python 3 function
def interpolate_gridded_scalar(self, x, y, c, order=1, pad=1, offset=0):

        ## no longer necessary because we accept pre-padded arrays
        # assert c.shape == (self.Ny, self.Nx), 'Shape of c needs to be (Ny,Nx)'

        # first pad the array to deal with the boundaries
        # (map_coordinates can't seem to deal with this by itself)
        # pad twice so cubic interpolation can be used
        if pad > 0:
            cp = self._pad_field(c, pad=pad)
        else:
            cp = c
        # now the shape is Nx+2, Nx+2
        i = (x - self.xmin)/self.Lx*self.Nx + pad + offset - 0.5
        j = (y - self.ymin)/self.Ly*self.Ny + pad + offset - 0.5

        # for some reason this still does not work with high precision near the boundaries
        return scipy.ndimage.map_coordinates(cp, [j,i],
                mode='constant', order=order, cval=np.nan)

Response: Interpolate gridded scalar C to points x y.


Instruction:
How would you implement a function in Python 3 that
advances particles using a gridded velocity field.

Response:
def step_forward_with_gridded_uv(self, U0, V0, U1, V1, dt, order=1):
        """Advance particles using a gridded velocity field. Because of the
        Runga-Kutta timestepping, we need two velocity fields at different
        times.

        Parameters
        ----------
        U0, V0 : array-like
            Gridded velocity fields at time t - dt.
        U1, V1 : array-like
            Gridded velocity fields at time t.
        dt : number
            Timestep.
        order : int
            Order of interpolation.
        """
        # create interpolation functions which return u and v

        # pre-pad arrays so it only has to be done once
        # for linear interpolation (default order=1), only one pad is necessary
        pad = order
        [U0p, V0p, U1p, V1p] = [self._pad_field(c, pad=pad) for c in [U0, V0, U1, V1]]

        # pad u and v as necessary
        uv0fun = (lambda x, y :
                  (self.interpolate_gridded_scalar(x, y, U0p,
                           pad=0, order=order, offset=pad),
                   self.interpolate_gridded_scalar(x, y, V0p,
                           pad=0, order=order, offset=pad)))
        uv1fun = (lambda x, y :
                  (self.interpolate_gridded_scalar(x, y, U1p, pad=0,
                           order=order, offset=pad),
                   self.interpolate_gridded_scalar(x, y, V1p, pad=0,
                           order=order, offset=pad)))

        self.step_forward_with_function(uv0fun, uv1fun, dt)


Instruction:
Implement a function in Python 3 to
compute the variance of p from Fourier coefficients ph.

Response:
def spec_var(model, ph):
    """Compute variance of ``p`` from Fourier coefficients ``ph``.

    Parameters
    ----------
    model : pyqg.Model instance
        The model object from which `ph` originates
    ph : complex array
        The field on which to compute the variance

    Returns
    -------
    var_dens : float
        The variance of `ph`
    """

    var_dens = 2. * np.abs(ph)**2 / model.M**2
    # only half of coefs [0] and [nx/2+1] due to symmetry in real fft2
    var_dens[...,0] /= 2
    var_dens[...,-1] /= 2
    return var_dens.sum(axis=(-1,-2))


Instruction:
Given the following Python 3 function, write the documentation
def spec_sum(ph2):

    ph2 = 2.*ph2
    ph2[...,0] = ph2[...,0]/2.
    ph2[...,-1] = ph2[...,-1]/2.

    return ph2.sum(axis=(-1,-2))

Response: Compute total spectral sum of the real spectral quantity ph^2


Instruction:
Can you tell what is the following Python 3 function doing
def calc_ispec(model, ph):

    if model.kk.max()>model.ll.max():
        kmax = model.ll.max()
    else:
        kmax = model.kk.max()

    # create radial wavenumber
    dkr = np.sqrt(model.dk**2 + model.dl**2)
    kr =  np.arange(dkr/2.,kmax+dkr,dkr)
    phr = np.zeros(kr.size)

    for i in range(kr.size):
        fkr =  (model.wv>=kr[i]-dkr/2) & (model.wv<=kr[i]+dkr/2)
        dth = pi / (fkr.sum()-1)
        phr[i] = ph[fkr].sum() * kr[i] * dth

    return kr, phr

Response: Compute isotropic spectrum phr of ph of model.


Instruction:
How would you explain what the following Python 3 function does
def _initialize_stretching_matrix(self):

        self.S = np.zeros((self.nz, self.nz))

        if (self.nz==2) and (self.rd) and (self.delta):

            self.del1 = self.delta/(self.delta+1.)
            self.del2 = (self.delta+1.)**-1
            self.Us = self.Ubg[0]-self.Ubg[1]

            self.F1 = self.rd**-2 / (1.+self.delta)
            self.F2 = self.delta*self.F1
            self.S[0,0], self.S[0,1] = -self.F1,  self.F1
            self.S[1,0], self.S[1,1] =  self.F2, -self.F2

        else:

            for i in range(self.nz):

                if i == 0:
                    self.S[i,i]   = -self.f2/self.Hi[i]/self.gpi[i]
                    self.S[i,i+1] =  self.f2/self.Hi[i]/self.gpi[i]

                elif i == self.nz-1:
                    self.S[i,i]   = -self.f2/self.Hi[i]/self.gpi[i-1]
                    self.S[i,i-1] =  self.f2/self.Hi[i]/self.gpi[i-1]

                else:
                    self.S[i,i-1] = self.f2/self.Hi[i]/self.gpi[i-1]
                    self.S[i,i]   = -(self.f2/self.Hi[i]/self.gpi[i] +
                                        self.f2/self.Hi[i]/self.gpi[i-1])
                    self.S[i,i+1] = self.f2/self.Hi[i]/self.gpi[i]

Response: Initialize the stretching matrix.


Instruction:
Explain what the following Python 3 code does
def _initialize_background(self):

        self.H = self.Hi.sum()
        if np.asarray(self.U).ndim == 2:
            self.Ubg = self.U * np.ones((self.ny))
        else:
            self.Ubg = np.expand_dims(self.U,axis=1) * np.ones((self.ny))

        if not (self.nz==2):
            self.gpi = self.g*(self.rhoi[1:]-self.rhoi[:-1])/self.rhoi[:-1]
            self.f2gpi = (self.f2/self.gpi)[:,np.newaxis,np.newaxis]

            assert self.gpi.size == self.nz-1, "Invalid size of gpi"

            assert np.all(self.gpi>0.), "Buoyancy jump has negative sign!"

            assert self.Hi.size == self.nz, self.logger.error('size of Hi does not' +
                     'match number of vertical levels nz')

            assert self.rhoi.size == self.nz, self.logger.error('size of rhoi does not' +
                     'match number of vertical levels nz')

            assert self.Ubg.size == self.nz * self.ny, self.logger.error('size of Ubg does not' +
                     'match number of vertical levels nz')

            assert self.Vbg.size == self.nz, self.logger.error('size of Vbg does not' +
                     'match number of vertical levels nz')

        else:
            self.f2gpi = np.array(self.rd**-2 *
                (self.Hi[0]*self.Hi[1])/self.H)[np.newaxis]

        self._initialize_stretching_matrix()

        # the meridional PV gradients in each layer
        self.Qy = self.beta - np.dot(self.S, self.Ubg) + np.gradient(np.gradient(self.Ubg, self.dy, axis=1), self.dy, axis=1)
        self.Qx = np.dot(self.S,self.Vbg)

        # complex versions, multiplied by k, speeds up computations to precompute
        self.ikQy = self.Qy[:,:,np.newaxis]*1j*self.k
        self.ilQx = self.Qx[:,np.newaxis,np.newaxis]*1j*self.l

Response: Initialize the background state of the current state of the class.


Instruction:
Write a Python 3 script to
estimate the eddy turn - over time in days

Response:
def _calc_eddy_time(self):
        """ estimate the eddy turn-over time in days """
        ens = 0.
        for j in range(self.nz):
            ens = .5*self.Hi[j] * self.spec_var(self.wv2*self.ph[j])

        return 2.*pi*np.sqrt( self.H / ens.sum() ) / 86400


Instruction:
Can you write a function in Python 3 where it
adds diagnostics for the layered model.

Response:
def _initialize_model_diagnostics(self):
        """ Extra diagnostics for layered model """

        self.add_diagnostic('entspec',
                description='barotropic enstrophy spectrum',
                function= (lambda self:
                    np.abs((self.Hi[:,np.newaxis,np.newaxis]*self.qh).sum(axis=0))**2/self.H) )

        self.add_diagnostic('KEspec_modal',
                description='modal KE spectra',
                function= (lambda self:
                    self.wv2*(np.abs(self.phn)**2)/self.M**2 ))

        self.add_diagnostic('PEspec_modal',
                description='modal PE spectra',
                function= (lambda self:
                    self.kdi2[1:,np.newaxis,np.newaxis]*(np.abs(self.phn[1:,:,:])**2)/self.M**2 ))

        self.add_diagnostic('APEspec',
                description='available potential energy spectrum',
                function= (lambda self:
                           (self.f2gpi*
                            np.abs(self.ph[:-1]-self.ph[1:])**2).sum(axis=0)/self.H))

        self.add_diagnostic('KEflux',
                    description='spectral divergence of flux of kinetic energy',
                    function =(lambda self: (self.Hi[:,np.newaxis,np.newaxis]*
                               (self.ph.conj()*self.Jpxi).real).sum(axis=0)/self.H))

        self.add_diagnostic('APEflux',
                    description='spectral divergence of flux of available potential energy',
                    function =(lambda self: (self.Hi[:,np.newaxis,np.newaxis]*
                               (self.ph.conj()*self.JSp).real).sum(axis=0)/self.H))

        self.add_diagnostic('APEgenspec',
                    description='the spectrum of the rate of generation of available potential energy',
                    function =(lambda self: (self.Hi[:,np.newaxis,np.newaxis]*
                                (self.Ubg[:,np.newaxis,np.newaxis]*self.k +
                                 self.Vbg[:,np.newaxis,np.newaxis]*self.l)*
                                (1j*self.ph.conj()*self.Sph).real).sum(axis=0)/self.H))

        self.add_diagnostic('ENSflux',
                 description='barotropic enstrophy flux',
                 function = (lambda self: (-self.Hi[:,np.newaxis,np.newaxis]*
                              (self.qh.conj()*self.Jq).real).sum(axis=0)/self.H))

        self.add_diagnostic('ENSgenspec',
                    description='the spectrum of the rate of generation of barotropic enstrophy',
                    function = (lambda self:
                            -(self.Hi[:,np.newaxis,np.newaxis]*((self.ikQy -
                            self.ilQx)*(self.Sph.conj()*self.ph)).real).sum(axis=0)/self.H))


Instruction:
How would you implement a function in Python 3 that
initializes the background state of the current log - level hierarchy.

Response:
def _initialize_background(self):
        """Set up background state (zonal flow and PV gradients)."""

        # Background zonal flow (m/s):
        self.H = self.Hi.sum()
        self.set_U1U2(self.U1, self.U2)
        self.U = self.U1 - self.U2

        # the F parameters
        self.F1 = self.rd**-2 / (1.+self.delta)
        self.F2 = self.delta*self.F1

        # the meridional PV gradients in each layer
        # need to calculate actual PV gradient
        self.Qy1 = self.beta + self.F1*(self.U1 - self.U2) + np.gradient(np.gradient(self.U1,self.dy),self.dy)
        self.Qy2 = self.beta - self.F2*(self.U1 - self.U2) + np.gradient(np.gradient(self.U2,self.dy),self.dy)
        self.Qy = np.array([self.Qy1, self.Qy2])
        # complex versions, multiplied by k, speeds up computations to precompute
        self.ikQy1 = self.Qy1[:,np.newaxis] * 1j * self.k
        self.ikQy2 = self.Qy2[:,np.newaxis] * 1j * self.k

        # vector version
        self.ikQy = np.vstack([self.ikQy1[np.newaxis,...],
                               self.ikQy2[np.newaxis,...]])
        self.ilQx = 0.

        # layer spacing
        self.del1 = self.delta/(self.delta+1.)
        self.del2 = (self.delta+1.)**-1


Instruction:
Write a Python 3 function that can
set the upper and lower layer PV anomalies.

Response:
def set_q1q2(self, q1, q2, check=False):
        """Set upper and lower layer PV anomalies.

        Parameters
        ----------

        q1 : array-like
            Upper layer PV anomaly in spatial coordinates.
        q1 : array-like
            Lower layer PV anomaly in spatial coordinates.
        """
        self.set_q(np.vstack([q1[np.newaxis,:,:], q2[np.newaxis,:,:]]))
        #self.q[0] = q1
        #self.q[1] = q2

        # initialize spectral PV
        #self.qh = self.fft2(self.q)

        # check that it works
        if check:
            np.testing.assert_allclose(self.q1, q1)
            np.testing.assert_allclose(self.q1, self.ifft2(self.qh1))


Instruction:
Make a summary of the following Python 3 code
def set_U1U2(self, U1, U2):
        if len(np.shape(U1)) == 0:
          U1 = U1 * np.ones((self.ny))
        if len(np.shape(U2)) == 0:
          U2 = U2 * np.ones((self.ny))
        #self.Ubg = np.array([U1,U2])[:,np.newaxis,np.newaxis]
        self.U1 = U1
        self.U2 = U2
        self.Ubg = np.array([U1,U2])

Response: Set background zonal flow.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _calc_eddy_time(self):

        ens = .5*self.Hi[0] * self.spec_var(self.wv2*self.ph1) + \
            .5*self.Hi[1] * self.spec_var(self.wv2*self.ph2)

        return 2.*pi*np.sqrt( self.H / ens ) / 86400

Response: estimate the eddy turn - over time in days


Instruction:
Can you generate the documentation for the following Python 3 function
def _initialize_model_diagnostics(self):

        self.add_diagnostic('entspec',
            description='barotropic enstrophy spectrum',
            function= (lambda self:
                      np.abs(self.del1*self.qh[0] + self.del2*self.qh[1])**2.)
        )

        self.add_diagnostic('APEflux',
            description='spectral flux of available potential energy',
            function= (lambda self:
              self.rd**-2 * self.del1*self.del2 *
              np.real((self.ph[0]-self.ph[1])*np.conj(self.Jptpc)) )
        )

        self.add_diagnostic('KEflux',
            description='spectral flux of kinetic energy',
            function= (lambda self:
              np.real(self.del1*self.ph[0]*np.conj(self.Jpxi[0])) +
              np.real(self.del2*self.ph[1]*np.conj(self.Jpxi[1])) )
        )

        self.add_diagnostic('APEgenspec',
            description='spectrum of APE generation',
            function= (lambda self: self.U[:,np.newaxis] * self.rd**-2 * self.del1 * self.del2 *
                       np.real(1j*self.k*(self.del1*self.ph[0] + self.del2*self.ph[1]) *
                                  np.conj(self.ph[0] - self.ph[1])) )
        )

        self.add_diagnostic('APEgen',
            description='total APE generation',
            function= (lambda self: self.U * self.rd**-2 * self.del1 * self.del2 *
                       np.real((1j*self.k*
                            (self.del1*self.ph[0] + self.del2*self.ph[1]) *
                            np.conj(self.ph[0] - self.ph[1])).sum()
                              +(1j*self.k[:,1:-2]*
                            (self.del1*self.ph[0,:,1:-2] + self.del2*self.ph[1,:,1:-2]) *
                            np.conj(self.ph[0,:,1:-2] - self.ph[1,:,1:-2])).sum()) /
                            (self.M**2) )
        )

Response: Initialize the diagnostics for the two - layer model.


Instruction:
Explain what the following Python 3 code does
def _initialize_inversion_matrix(self):
        # The bt model is diagonal. The inversion is simply qh = -kappa**2 ph
        self.a = -(self.wv2i+self.kd2)[np.newaxis, np.newaxis, :, :]

Response: initialize the inversion matrix


Instruction:
Implement a function in Python 3 to
estimate the eddy turn - over time in days

Response:
def _calc_eddy_time(self):
        """ estimate the eddy turn-over time in days """
        ens = .5*self.H * self.spec_var(self.wv2*self.ph)
        return 2.*pi*np.sqrt( self.H / ens ) / year


Instruction:
Write a Python 3 script for
calculating velocity at x and y points due to vortex velocity field.

Response:
def calc_uv(self, x, y, prev=False):
        """Calculate velocity at x and y points due to vortex velocity field.
        Assumes x and y are vortex positions and are ordered the same as
        x0 and y0. The ordering is used to neglect to vortex self interaction."""
        assert len(x) == self.N
        assert len(y) == self.N
        u = np.zeros(self.N, self.x.dtype)
        v = np.zeros(self.N, self.y.dtype)
        for n in xrange(self.N):
            # don't include self interaction
            if prev:
                x0 = self.xprev[np.r_[:n,n+1:self.N]]
                y0 = self.yprev[np.r_[:n,n+1:self.N]]
            else:
                x0 = self.x[np.r_[:n,n+1:self.N]]
                y0 = self.y[np.r_[:n,n+1:self.N]]
            s0 = self.s[np.r_[:n,n+1:self.N]]
            u0, v0 = self.uv_at_xy(x[n], y[n], x0, y0, s0)
            u[n] = u0.sum()
            v[n] = v0.sum()
        return u, v


Instruction:
Here you have a function in Python 3, explain what it does
def uv_at_xy(self, x, y, x0, y0, s0):
        dx, dy = self.distance(x0, y0, x, y)
        #print 'dx, dy:', dx, dy
        rr2 = (dx**2 + dy**2)**-1
        u = - s0 * dy * r_twopi * rr2
        v = s0 * dx * r_twopi * rr2
        #print 'u, v', u, v
        return u, v

Response: Returns two arrays of u v at x y


Instruction:
Create a Python 3 function for
reducing the list of arguments into a single list of the same size.

Response:
def reduce(args):
    """
    >>> reduce([(2, 4), (4, 9)])
    [(2, 4), (4, 9)]

    >>> reduce([(2, 6), (4, 10)])
    [(2, 10)]
    """
    if len(args) < 2: return args
    args.sort()
    ret = [args[0]]
    for next_i, (s, e) in enumerate(args, start=1):
        if next_i == len(args):
            ret[-1] = ret[-1][0], max(ret[-1][1], e)
            break

        ns, ne = args[next_i]
        if e > ns or ret[-1][1] > ns:
            ret[-1] = ret[-1][0], max(e, ne, ret[-1][1])
        else:
            ret.append((ns, ne))
    return ret


Instruction:
Can you generate a brief explanation for the following Python 3 code
def find(self, other):
        iset = self._iset
        l = binsearch_left_start(iset, other[0] - self._maxlen, 0, len(iset))
        r = binsearch_right_end(iset, other[1], 0, len(iset))
        iopts = iset[l:r]
        iiter = (s for s in iopts if s[0] <= other[1] and s[1] >= other[0])
        for o in iiter: yield o

Response: Return an interable of elements that overlap other in the tree.


Instruction:
Write a Python 3 script for
loading the dictionary from a specific JSON file.

Response:
def loaddict(filename=DICTIONARY):
    """
    Load the dictionary from a specific JSON file.
    """
    global zhcdicts
    if zhcdicts:
        return
    if filename == _DEFAULT_DICT:
        zhcdicts = json.loads(get_module_res(filename).read().decode('utf-8'))
    else:
        with open(filename, 'rb') as f:
            zhcdicts = json.loads(f.read().decode('utf-8'))
    zhcdicts['SIMPONLY'] = frozenset(zhcdicts['SIMPONLY'])
    zhcdicts['TRADONLY'] = frozenset(zhcdicts['TRADONLY'])


Instruction:
Can you write a function in Python 3 where it
generates or get convertion dict cache for certain locale.

Response:
def getdict(locale):
    """
    Generate or get convertion dict cache for certain locale.
    Dictionaries are loaded on demand.
    """
    global zhcdicts, dict_zhcn, dict_zhsg, dict_zhtw, dict_zhhk, pfsdict
    if zhcdicts is None:
        loaddict(DICTIONARY)
    if locale == 'zh-cn':
        if dict_zhcn:
            got = dict_zhcn
        else:
            dict_zhcn = zhcdicts['zh2Hans'].copy()
            dict_zhcn.update(zhcdicts['zh2CN'])
            got = dict_zhcn
    elif locale == 'zh-tw':
        if dict_zhtw:
            got = dict_zhtw
        else:
            dict_zhtw = zhcdicts['zh2Hant'].copy()
            dict_zhtw.update(zhcdicts['zh2TW'])
            got = dict_zhtw
    elif locale == 'zh-hk' or locale == 'zh-mo':
        if dict_zhhk:
            got = dict_zhhk
        else:
            dict_zhhk = zhcdicts['zh2Hant'].copy()
            dict_zhhk.update(zhcdicts['zh2HK'])
            got = dict_zhhk
    elif locale == 'zh-sg' or locale == 'zh-my':
        if dict_zhsg:
            got = dict_zhsg
        else:
            dict_zhsg = zhcdicts['zh2Hans'].copy()
            dict_zhsg.update(zhcdicts['zh2SG'])
            got = dict_zhsg
    elif locale == 'zh-hans':
        got = zhcdicts['zh2Hans']
    elif locale == 'zh-hant':
        got = zhcdicts['zh2Hant']
    else:
        got = {}
    if locale not in pfsdict:
        pfsdict[locale] = getpfset(got)
    return got


Instruction:
Make a summary of the following Python 3 code
def issimp(s, full=False):
    if zhcdicts is None:
        loaddict(DICTIONARY)
    simp, trad = 0, 0
    if full:
        for ch in s:
            if ch in zhcdicts['SIMPONLY']:
                simp += 1
            elif ch in zhcdicts['TRADONLY']:
                trad += 1
        if simp > trad:
            return True
        elif simp < trad:
            return False
        else:
            return None
    else:
        for ch in s:
            if ch in zhcdicts['SIMPONLY']:
                return True
            elif ch in zhcdicts['TRADONLY']:
                return False
        return None

Response: Detect text is whether Simplified Chinese or Traditional Chinese.


Instruction:
Given the following Python 3 function, write the documentation
def convtable2dict(convtable, locale, update=None):
    rdict = update.copy() if update else {}
    for r in convtable:
        if ':uni' in r:
            if locale in r:
                rdict[r[':uni']] = r[locale]
        elif locale[:-1] == 'zh-han':
            if locale in r:
                for word in r.values():
                    rdict[word] = r[locale]
        else:
            v = fallback(locale, r)
            for word in r.values():
                rdict[word] = v
    return rdict

Response: Convert a list of conversion dict to a dict for a certain locale.


Instruction:
Explain what the following Python 3 code does
def tokenize(s, locale, update=None):
    zhdict = getdict(locale)
    pfset = pfsdict[locale]
    if update:
        zhdict = zhdict.copy()
        zhdict.update(update)
        newset = set()
        for word in update:
            for ch in range(len(word)):
                newset.add(word[:ch+1])
        pfset = pfset | newset
    ch = []
    N = len(s)
    pos = 0
    while pos < N:
        i = pos
        frag = s[pos]
        maxword = None
        maxpos = 0
        while i < N and frag in pfset:
            if frag in zhdict:
                maxword = frag
                maxpos = i
            i += 1
            frag = s[pos:i+1]
        if maxword is None:
            maxword = s[pos]
            pos += 1
        else:
            pos = maxpos + 1
        ch.append(maxword)
    return ch

Response: Tokenize s according to corresponding locale dictionary.


Instruction:
Implement a function in Python 3 to
convert a MediaWiki string to a human - readable format.

Response:
def convert_for_mw(s, locale, update=None):
    """
    Recognizes MediaWiki's human conversion format.
    Use locale='zh' for no conversion.

    Reference: (all tests passed)
    https://zh.wikipedia.org/wiki/Help:高级字词转换语法
    https://www.mediawiki.org/wiki/Writing_systems/Syntax

    >>> print(convert_for_mw('在现代，机械计算-{}-机的应用已经完全被电子计算-{}-机所取代', 'zh-hk'))
    在現代，機械計算機的應用已經完全被電子計算機所取代
    >>> print(convert_for_mw('-{zh-hant:資訊工程;zh-hans:计算机工程学;}-是电子工程的一个分支，主要研究计算机软硬件和二者间的彼此联系。', 'zh-tw'))
    資訊工程是電子工程的一個分支，主要研究計算機軟硬體和二者間的彼此聯繫。
    >>> print(convert_for_mw('張國榮曾在英國-{zh:利兹;zh-hans:利兹;zh-hk:列斯;zh-tw:里茲}-大学學習。', 'zh-hant'))
    張國榮曾在英國里茲大學學習。
    >>> print(convert_for_mw('張國榮曾在英國-{zh:利兹;zh-hans:利兹;zh-hk:列斯;zh-tw:里茲}-大学學習。', 'zh-sg'))
    张国荣曾在英国利兹大学学习。
    >>> convert_for_mw('-{zh-hant:;\\nzh-cn:}-', 'zh-tw') == ''
    True
    >>> print(convert_for_mw('毫米(毫公分)，符號mm，是長度單位和降雨量單位，-{zh-hans:台湾作-{公釐}-或-{公厘}-;zh-hant:港澳和大陸稱為-{毫米}-（台灣亦有使用，但較常使用名稱為毫公分）;zh-mo:台灣作-{公釐}-或-{公厘}-;zh-hk:台灣作-{公釐}-或-{公厘}-;}-。', 'zh-tw'))
    毫米(毫公分)，符號mm，是長度單位和降雨量單位，港澳和大陸稱為毫米（台灣亦有使用，但較常使用名稱為毫公分）。
    >>> print(convert_for_mw('毫米(毫公分)，符號mm，是長度單位和降雨量單位，-{zh-hans:台湾作-{公釐}-或-{公厘}-;zh-hant:港澳和大陸稱為-{毫米}-（台灣亦有使用，但較常使用名稱為毫公分）;zh-mo:台灣作-{公釐}-或-{公厘}-;zh-hk:台灣作-{公釐}-或-{公厘}-;}-。', 'zh-cn'))
    毫米(毫公分)，符号mm，是长度单位和降雨量单位，台湾作公釐或公厘。
    >>> print(convert_for_mw('毫米(毫公分)，符號mm，是長度單位和降雨量單位，-{zh-hans:台湾作-{公釐}-或-{公厘}-;zh-hant:港澳和大陸稱為-{毫米}-（台灣亦有使用，但較常使用名稱為毫公分）;zh-mo:台灣作-{公釐}-或-{公厘}-;zh-hk:台灣作-{公釐}-或-{公厘', 'zh-hk'))  # unbalanced test
    毫米(毫公分)，符號mm，是長度單位和降雨量單位，台灣作公釐或公厘
    >>> print(convert_for_mw('报头的“-{參攷消息}-”四字摘自鲁迅笔迹-{zh-hans:，“-{參}-”是“-{参}-”的繁体字，读音cān，与简体的“-{参}-”字相同；;zh-hant:，;}-“-{攷}-”是“考”的异体字，读音kǎo，与“考”字相同。', 'zh-tw'))
    報頭的「參攷消息」四字摘自魯迅筆跡，「攷」是「考」的異體字，讀音kǎo，與「考」字相同。
    >>> print(convert_for_mw('报头的“-{參攷消息}-”四字摘自鲁迅笔迹-{zh-hans:，“-{參}-”是“-{参}-”的繁体字，读音cān，与简体的“-{参}-”字相同；;zh-hant:，;}-“-{攷}-”是“考”的异体字，读音kǎo，与“考”字相同。', 'zh-cn'))
    报头的“參攷消息”四字摘自鲁迅笔迹，“參”是“参”的繁体字，读音cān，与简体的“参”字相同；“攷”是“考”的异体字，读音kǎo，与“考”字相同。
    >>> print(convert_for_mw('{{Col-break}}-->', 'zh-hant'))
    {{Col-break}}-->
    """
    ch = []
    rules = []
    ruledict = update.copy() if update else {}
    nested = 0
    block = ''
    for frag in RE_langconv.split(s):
        if frag == '-{':
            nested += 1
            block += frag
        elif frag == '}-':
            if not nested:
                # bogus }-
                ch.append(frag)
                continue
            block += frag
            nested -= 1
            if nested:
                continue
            newrules = []
            delim = RE_splitflag.split(block[2:-2].strip(' \t\n\r\f\v;'))
            if len(delim) == 1:
                flag = None
                mapping = RE_splitmap.split(delim[0])
            else:
                flag = RE_splitmap.split(delim[0].strip(' \t\n\r\f\v;'))
                mapping = RE_splitmap.split(delim[1])
            rule = {}
            for m in mapping:
                uni = RE_splituni.split(m)
                if len(uni) == 1:
                    pair = RE_splitpair.split(uni[0])
                else:
                    if rule:
                        newrules.append(rule)
                        rule = {':uni': uni[0]}
                    else:
                        rule[':uni'] = uni[0]
                    pair = RE_splitpair.split(uni[1])
                if len(pair) == 1:
                    rule['zh'] = convert_for_mw(pair[0], 'zh', ruledict)
                else:
                    rule[pair[0]] = convert_for_mw(pair[1], pair[0], ruledict)
            newrules.append(rule)
            if not flag:
                ch.append(fallback(locale, newrules[0]))
            elif any(ch in flag for ch in 'ATRD-HN'):
                for f in flag:
                    # A: add rule for convert code (all text convert)
                    # H: Insert a conversion rule without output
                    if f in ('A', 'H'):
                        for r in newrules:
                            if not r in rules:
                                rules.append(r)
                        if f == 'A':
                            if ':uni' in r:
                                if locale in r:
                                    ch.append(r[locale])
                                else:
                                    ch.append(convert(r[':uni'], locale))
                            else:
                                ch.append(fallback(locale, newrules[0]))
                    # -: remove convert
                    elif f == '-':
                        for r in newrules:
                            try:
                                rules.remove(r)
                            except ValueError:
                                pass
                    # D: convert description (useless)
                    #elif f == 'D':
                        #ch.append('; '.join(': '.join(x) for x in newrules[0].items()))
                    # T: title convert (useless)
                    # R: raw content (implied above)
                    # N: current variant name (useless)
                    #elif f == 'N':
                        #ch.append(locale)
                ruledict = convtable2dict(rules, locale, update)
            else:
                fblimit = frozenset(flag) & frozenset(Locales[locale])
                limitedruledict = update.copy() if update else {}
                for r in rules:
                    if ':uni' in r:
                        if locale in r:
                            limitedruledict[r[':uni']] = r[locale]
                    else:
                        v = None
                        for l in Locales[locale]:
                            if l in r and l in fblimit:
                                v = r[l]
                                break
                        for word in r.values():
                            limitedruledict[word] = v if v else convert(word, locale)
                ch.append(convert(delim[1], locale, limitedruledict))
            block = ''
        elif nested:
            block += frag
        else:
            ch.append(convert(frag, locale, ruledict))
    if nested:
        # unbalanced
        ch.append(convert_for_mw(block + '}-'*nested, locale, ruledict))
    return ''.join(ch)


Instruction:
Can you tell what is the following Python 3 function doing
def bucket_lister(manager, bucket_name, prefix=None, marker=None, limit=None):
    eof = False
    while not eof:
        ret, eof, info = manager.list(bucket_name, prefix=prefix, limit=limit,
                                      marker=marker)
        if ret is None:
            raise QiniuError(info)
        if not eof:
            marker = ret['marker']

        for item in ret['items']:
            yield item

Response: A generator function for listing keys in a bucket.


Instruction:
Make a summary of the following Python 3 code
def get_qiniu_config(name, default=None):
    config = os.environ.get(name, getattr(settings, name, default))
    if config is not None:
        if isinstance(config, six.string_types):
            return config.strip()
        else:
            return config
    else:
        raise ImproperlyConfigured(
            "Can't find config for '%s' either in environment"
            "variable or in setting.py" % name)

Response:
Get a Qiniu configuration variable from environment variable
    or django setting. py


Instruction:
Implement a Python 3 function for
performing a register with type m. login. application_service AttributeNames

Response:
def register(self, username=""):
        """Performs /register with type: m.login.application_service

        Args:
            username(str): Username to register.
        """
        if not username:
            username = utils.mxid2localpart(self.identity)
        content = {
            "type": "m.login.application_service",
            "username": username,
        }
        return self._send("POST", "/register", content,
                          api_path=MATRIX_V2_API_PATH)


Instruction:
Can you tell what is the following Python 3 function doing
def load_from_file(filename):
    if os.path.isdir(filename):
        logger.error("Err: File '%s' is a directory", filename)
        return None
    if not os.path.isfile(filename):
        logger.error("Err: File '%s' does not exist", filename)
        return None

    try:
        with open(filename, 'r') as sourcefile:
            songs = [line.strip() for line in sourcefile]
    except IOError as error:
        logger.exception(error)
        return None
    songs = set(Song.from_filename(song) for song in songs)
    return songs.difference({None})

Response: Load a list of filenames from an external text file.


Instruction:
Write a Python 3 script for
parsing command line arguments and return a dictionary of configuration variables.

Response:
def parse_argv():
    """
    Parse command line arguments. Settings will be stored in the global
    variables declared above.
    """
    parser = argparse.ArgumentParser(description='Find lyrics for a set of mp3'
                                     ' files and embed them as metadata')
    parser.add_argument('-j', '--jobs', help='Number of parallel processes',
                        type=int, metavar='N', default=1)
    parser.add_argument('-o', '--overwrite', help='Overwrite lyrics of songs'
                        ' that already have them', action='store_true')
    parser.add_argument('-s', '--stats', help='Print a series of statistics at'
                        ' the end of the execution', action='store_true')
    parser.add_argument('-v', '--verbose', help='Set verbosity level (pass it'
                        ' up to three times)', action='count')
    parser.add_argument('-d', '--debug', help='Enable debug output',
                        action='store_true')
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-r', '--recursive', help='Recursively search for'
                       ' mp3 files', metavar='path', nargs='?', const='.')
    group.add_argument('--from-file', help='Read a list of files from a text'
                       ' file', type=str)
    parser.add_argument('songs', help='The files/songs to search lyrics for',
                        nargs='*')

    args = parser.parse_args()

    CONFIG['overwrite'] = args.overwrite
    CONFIG['print_stats'] = args.stats

    if args.verbose is None or args.verbose == 0:
        logger.setLevel(logging.CRITICAL)
    elif args.verbose == 1:
        logger.setLevel(logging.INFO)
    else:
        logger.setLevel(logging.DEBUG)

    if args.jobs <= 0:
        msg = 'Argument -j/--jobs should have a value greater than zero'
        parser.error(msg)
    else:
        CONFIG['jobcount'] = args.jobs

    songs = set()
    if args.from_file:
        songs = load_from_file(args.from_file)
        if not songs:
            raise ValueError('No file names found in file')
    elif args.recursive:
        mp3files = glob.iglob(args.recursive + '/**/*.mp3', recursive=True)
        songs = set(Song.from_filename(f) for f in mp3files)
    elif args.songs:
        if os.path.exists(args.songs[0]):
            parser = Song.from_filename
        else:
            parser = Song.from_string
        songs.update(map(parser, args.songs))
    else:
        songs.add(get_current_song())

    # Just in case some song constructors failed, remove all the Nones
    return songs.difference({None})


Instruction:
Write a Python 3 script for
decoding a base64 - encoded UUID object.

Response:
def decode(slug):
    """
    Returns the uuid.UUID object represented by the given v4 or "nice" slug
    """
    if sys.version_info.major != 2 and isinstance(slug, bytes):
        slug = slug.decode('ascii')
    slug = slug + '=='  # base64 padding
    return uuid.UUID(bytes=base64.urlsafe_b64decode(slug))


Instruction:
Write a Python 3 script to
return a randomly generated uuid v4 compliant slug that conforms to a set of nice properties.

Response:
def nice():
    """
    Returns a randomly generated uuid v4 compliant slug which conforms to a set
    of "nice" properties, at the cost of some entropy. Currently this means one
    extra fixed bit (the first bit of the uuid is set to 0) which guarantees the
    slug will begin with [A-Za-f]. For example such slugs don't require special
    handling when used as command line parameters (whereas non-nice slugs may
    start with `-` which can confuse command line tools).

    Potentially other "nice" properties may be added in future to further
    restrict the range of potential uuids that may be generated.
    """
    rawBytes = bytearray(uuid.uuid4().bytes)
    rawBytes[0] = rawBytes[0] & 0x7f  # Ensure slug starts with [A-Za-f]
    return _convert_bytes_to_slug(rawBytes)


Instruction:
Create a Python 3 function for
filtering mutations that are in the given normal.

Response:
def filter_against_normal(self, normal_mutations, maf_min=0.2,
                              maf_count_threshold=20, count_min=1):
        """Filters mutations that are in the given normal"""
        assert(normal_mutations.chrom == self.chrom)
        assert(normal_mutations.pos == self.pos)
        assert(normal_mutations.ref == self.ref)

        def passes_normal_criteria(mut):
            return (mut.count >= maf_count_threshold and mut.maf > maf_min) or \
                (mut.count < maf_count_threshold and mut.count > count_min)

        nms = normal_mutations
        muts = MutationsAtSinglePosition(self.chrom, self.pos, self.cov, self.ref)

        for snv in self.snvs:
            if not (snv in nms.snvs and passes_normal_criteria(nms.snvs[snv])):
                muts.add_snv(self.snvs[snv])

        for dlt in self.deletions:
            if not (dlt in nms.deletions and passes_normal_criteria(nms.deletions[dlt])):
                muts.add_deletion(self.deletions[dlt])

        for ins in self.insertions:
            if not (ins in nms.insertions and passes_normal_criteria(nms.insertions[ins])):
                muts.add_insertion(self.insertions[ins])

        return muts


Instruction:
Can you tell what is the following Python 3 function doing
def to_oncotator(self):
        if self.type == ".":
            ref = self.ref
            alt = self.change
            start = self.pos
            end = self.pos
        elif self.type == "-":
            ref = self.change
            alt = "-"
            start = self.pos + 1
            end = start + len(self.change)
        elif self.type == "+":
            ref = "-"
            alt = self.change
            start = self.pos
            end = start + len(self.change)
        else:
            raise(Exception("Unexpected mutation type: {}".format(self.type)))
        return "{chrom}\t{start}\t{end}\t{ref}\t{alt}".format(chrom=self.chrom, start=start,
                                                            end=end, ref=ref, alt=alt)

Response:
Returns the mutation in oncotator input format. Assumes mutations have
            vcf style positions.


Instruction:
Write a Python 3 function that can
add routes to Application that use specified handlers.

Response:
def add_handlers(self, room_handler=None, transaction_handler=None,
                     user_handler=None):
        """Adds routes to Application that use specified handlers."""
        # Add all the normal matrix API routes
        if room_handler:
            room = resources.Room(room_handler,
                                  self.Api)
            self.add_route("/rooms/{room_alias}", room)
        if transaction_handler:
            transaction = resources.Transaction(transaction_handler,
                                                self.Api)
            self.add_route("/transactions/{txn_id}", transaction)
        if user_handler:
            user = resources.User(user_handler,
                                  self.Api)
            self.add_route("/users/{user_id}", user)


Instruction:
Can you implement a function in Python 3 that
merges values in place from *right* into *left*. :param left: mapping to merge into :param right: mapping to merge from :param path: `list` of keys processed before (used for error reporting only, should only need to be provided by recursive calls) :param conflict: action to be taken on merge conflict, raising an error or overwriting an existing value :return: *left*, for convenience

Response:
def _merge(left, right, path=None, conflict=_Conflict.error):
    """
    Merges values in place from *right* into *left*.

    :param left: mapping to merge into
    :param right: mapping to merge from
    :param path: `list` of keys processed before (used for error reporting
        only, should only need to be provided by recursive calls)
    :param conflict: action to be taken on merge conflict, raising an error
        or overwriting an existing value
    :return: *left*, for convenience
    """
    path = path or []
    conflict = _Conflict(conflict)

    for key in right:
        if key in left:
            if isinstance(left[key], Mapping) and isinstance(right[key], Mapping):
                # recurse, merge left and right dict values, update path for current 'step'
                _merge(left[key], right[key], path + [key], conflict=conflict)
            elif left[key] != right[key]:
                if conflict is _Conflict.error:
                    # not both dicts we could merge, but also not the same, this doesn't work
                    conflict_path = '.'.join(path + [key])
                    raise MergeConflictError('merge conflict at {}'.format(conflict_path), key=conflict_path)
                else:
                    # overwrite left value with right value
                    left[key] = right[key]
            # else: left[key] is already equal to right[key], no action needed
        else:
            # key not yet in left or not considering conflicts, simple addition of right's mapping to left
            left[key] = right[key]

    return left


Instruction:
Can you tell what is the following Python 3 function doing
def log_mon_value(name, value=1, **kwargs):
    message = '{} => {}'.format(name, value)
    log_mon.info({'metric_name': name, 'value': value, 'message': message, **kwargs})

Response: simplest monitoring function to be aggregated with sum


Instruction:
Here you have a function in Python 3, explain what it does
def use_form(form_class, request=None, **top_kwargs):

    def validated_form(request, **kwargs):
        # import ipdb; ipdb.set_trace()
        data = request.query_params.dict() if request.method in ['GET'] else request.data
        if isinstance(data, QueryDict):
            form = form_class(data={**data.dict(), **kwargs})
        elif isinstance(data, dict):
            form = form_class(data={**data, **kwargs})
        else:
            form = form_class(data=data, **kwargs)
        form.is_valid(raise_exception=True)
        return form

    if request:
        kwargs = {}
        if request.resolver_match:
            kwargs = {**request.resolver_match.kwargs}
        if top_kwargs:
            kwargs = {**kwargs, **top_kwargs}

        return validated_form(request, **kwargs).validated_data

    def wrap(func):
        def method_wrap(view, request, *args, **kwargs):
            form = validated_form(request, **kwargs)
            if hasattr(view, 'log'):
                form.log = view.log
            return func(view, form.validated_data, *args, **kwargs)

        def function_wrap(request, *args, **kwargs):
            form = validated_form(request, **kwargs)
            return func(form.validated_data, *args, **kwargs)

        def inner(*args, **kwargs):
            is_method = isinstance(args[0], APIView)
            return (method_wrap if is_method else function_wrap)(*args, **kwargs)

        return inner

    return wrap

Response: Use a form to create a new object.


Instruction:
Here you have a function in Python 3, explain what it does
def dx_orbit_sys(t, X):
    '''X = [
    m1x, m1y,
    m2x, m2y,
    m3x, m3y,
    m4x, m4y,
    m1vx, m1vy,
    m2vx, m2vy,
    m3vx, m3vy,
    m4vx, m4vy
    ]
    '''
    (m1x, m1y,
     m2x, m2y,
     m3x, m3y,
     m4x, m4y,
     m1vx, m1vy,
     m2vx, m2vy,
     m3vx, m3vy,
     m4vx, m4vy) = X
    m_moon1 = 7.342*(10**22)  # kg
    m_moon2 = 7.342*(10**22)  # kg
    m_moon3 = 7.342*(10**22)  # kg
    m_moon4 = 7.342*(10**22)  # kg
    G = 6.67408*(10**-11)  # m**3 kg**−1 s**−2
    dm12 = sqrt((m1x - m2x)**2 + (m1y - m2y)**2)
    dm13 = sqrt((m1x - m3x)**2 + (m1y - m3y)**2)
    dm14 = sqrt((m1x - m4x)**2 + (m1y - m4y)**2)
    dm23 = sqrt((m2x - m3x)**2 + (m2y - m3y)**2)
    dm24 = sqrt((m2x - m4x)**2 + (m2y - m4y)**2)
    dm34 = sqrt((m3x - m4x)**2 + (m3y - m4y)**2)
    f12 = G * m_moon1 * m_moon2 / (dm12 * dm12)
    f13 = G * m_moon1 * m_moon3 / (dm13 * dm13)
    f14 = G * m_moon1 * m_moon4 / (dm14 * dm14)
    f23 = G * m_moon2 * m_moon3 / (dm23 * dm23)
    f24 = G * m_moon2 * m_moon4 / (dm24 * dm24)
    f34 = G * m_moon3 * m_moon4 / (dm34 * dm34)
    dr12 = atan2(m2y - m1y, m2x - m1x)
    dr13 = atan2(m3y - m1y, m3x - m1x)
    dr14 = atan2(m4y - m1y, m4x - m1x)
    dr23 = atan2(m3y - m2y, m3x - m2x)
    dr24 = atan2(m4y - m2y, m4x - m2x)
    dr34 = atan2(m4y - m3y, m4x - m3x)
    f1x = f12 * cos(dr12) + f13 * cos(dr13) + f14 * cos(dr14)
    f1y = f12 * sin(dr12) + f13 * sin(dr13) + f14 * sin(dr14)
    f2x = f12 * cos(dr12 + pi) + f23 * cos(dr23) + f24 * cos(dr24)
    f2y = f12 * sin(dr12 + pi) + f23 * sin(dr23) + f24 * sin(dr24)
    f3x = f13 * cos(dr13 + pi) + f23 * cos(dr23 + pi) + f34 * cos(dr34)
    f3y = f13 * sin(dr13 + pi) + f23 * sin(dr23 + pi) + f34 * sin(dr34)
    f4x = f14 * cos(dr14 + pi) + f24 * cos(dr24 + pi) + f34 * cos(dr34 + pi)
    f4y = f14 * sin(dr14 + pi) + f24 * sin(dr24 + pi) + f34 * sin(dr34 + pi)
    dX = [
            m1vx,
            m1vy,
            m2vx,
            m2vy,
            m3vx,
            m3vy,
            m4vx,
            m4vy,
            f1x / m_moon1,
            f1y / m_moon1,
            f2x / m_moon2,
            f2y / m_moon2,
            f3x / m_moon3,
            f3y / m_moon3,
            f4x / m_moon4,
            f4y / m_moon4,
            ]
    return dX

Response: An orbit system of the given moon.


Instruction:
Here you have a function in Python 3, explain what it does
def add(self, client):
        if client.pool_id in self._client_ids:
            log.info("%r is already in the penalty box. Ignoring.", client)
            return
        release = time.time() + self._min_wait
        heapq.heappush(self._clients, (release, (client, self._min_wait)))
        self._client_ids.add(client.pool_id)

Response: Adds a client to the penalty box.


Instruction:
Can you tell what is the following Python 3 function doing
def get(self):
        now = time.time()
        while self._clients and self._clients[0][0] < now:
            _, (client, last_wait) = heapq.heappop(self._clients)
            connect_start = time.time()
            try:
                client.echo("test")  # reconnected if this succeeds.
                self._client_ids.remove(client.pool_id)
                yield client
            except (ConnectionError, TimeoutError):
                timer = time.time() - connect_start
                wait = min(int(last_wait * self._multiplier), self._max_wait)
                heapq.heappush(self._clients, (time.time() + wait, (client, wait)))
                log.info(
                    "%r is still down after a %s second attempt to connect. Retrying in %ss.",
                    client,
                    timer,
                    wait,
                )

Response: Get any clients ready to be used.


Instruction:
Can you tell what is the following Python 3 function doing
def string(_object):
    if is_callable(_object):
        _validator = _object

        @wraps(_validator)
        def decorated(value):
            ensure(isinstance(value, basestring), "not of type string")
            return _validator(value)
        return decorated
    ensure(isinstance(_object, basestring), "not of type string")

Response: Validates a given input is of type string.


Instruction:
Write a Python 3 script for
validating a given input is of type boolean.

Response:
def boolean(_object):
    """
    Validates a given input is of type boolean.

    Example usage::

        data = {'a' : True}
        schema = ('a', boolean)

    You can also use this as a decorator, as a way to check for the
    input before it even hits a validator you may be writing.

    .. note::
        If the argument is a callable, the decorating behavior will be
        triggered, otherwise it will act as a normal function.

    """
    if is_callable(_object):
        _validator = _object

        @wraps(_validator)
        def decorated(value):
            ensure(isinstance(value, bool), "not of type boolean")
            return _validator(value)
        return decorated
    ensure(isinstance(_object, bool), "not of type boolean")


Instruction:
Can you generate a brief explanation for the following Python 3 code
def dictionary(_object, *args):
    error_msg = 'not of type dictionary'
    if is_callable(_object):
        _validator = _object

        @wraps(_validator)
        def decorated(value):
            ensure(isinstance(value, dict), error_msg)
            return _validator(value)
        return decorated
    try:
        ensure(isinstance(_object, dict), error_msg)
    except AssertionError:
        if args:
            msg = 'did not pass validation against callable: dictionary'
            raise Invalid('', msg=msg, reason=error_msg, *args)
        raise

Response: Validates a given input is of type dictionary.


Instruction:
How would you explain what the following Python 3 function does
def array(_object):
    if is_callable(_object):
        _validator = _object

        @wraps(_validator)
        def decorated(value):
            ensure(isinstance(value, list), "not of type array")
            return _validator(value)
        return decorated
    ensure(isinstance(_object, list), "not of type array")

Response: Validates a given input is of type list.


Instruction:
Write a Python 3 script for
validating a given input is of type int..

Response:
def integer(_object):
    """
    Validates a given input is of type int..

    Example usage::

        data = {'a' : 21}
        schema = ('a', integer)

    You can also use this as a decorator, as a way to check for the
    input before it even hits a validator you may be writing.

    .. note::
        If the argument is a callable, the decorating behavior will be
        triggered, otherwise it will act as a normal function.
    """
    if is_callable(_object):
        _validator = _object

        @wraps(_validator)
        def decorated(value):
            ensure(isinstance(value, int), "not of type int")
            return _validator(value)
        return decorated
    ensure(isinstance(_object, int), "not of type int")


Instruction:
How would you implement a function in Python 3 that
returns a constant value TensorFluent with given dtype.

Response:
def constant(cls,
            value: Value,
            dtype: tf.DType = tf.float32) -> 'TensorFluent':
        '''Returns a constant `value` TensorFluent with given `dtype`.

        Args:
            value: The constant value.
            dtype: The output's data type.

        Returns:
            A constant TensorFluent.
        '''
        t = tf.constant(value, dtype=dtype)
        scope = [] # type: List
        batch = False
        return TensorFluent(t, scope, batch=batch)


Instruction:
Explain what the following Python 3 code does
def Bernoulli(cls,
        mean: 'TensorFluent',
        batch_size: Optional[int] = None) -> Tuple[Distribution, 'TensorFluent']:
        '''Returns a TensorFluent for the Bernoulli sampling op with given mean parameter.

        Args:
            mean: The mean parameter of the Bernoulli distribution.
            batch_size: The size of the batch (optional).

        Returns:
            The Bernoulli distribution and a TensorFluent sample drawn from the distribution.
        '''
        probs = mean.tensor
        dist = tf.distributions.Bernoulli(probs=probs, dtype=tf.bool)
        batch = mean.batch
        if not batch and batch_size is not None:
            t = dist.sample(batch_size)
            batch = True
        else:
            t = dist.sample()
        scope = mean.scope.as_list()
        return (dist, TensorFluent(t, scope, batch=batch))

Response: Returns a TensorFluent for the Bernoulli sampling op with given mean parameter.


Instruction:
Can you create a Python 3 function that
returns a TensorFluent for the Uniform sampling op with given low and high parameters.

Response:
def Uniform(cls,
            low: 'TensorFluent', high: 'TensorFluent',
            batch_size: Optional[int] = None) -> Tuple[Distribution, 'TensorFluent']:
        '''Returns a TensorFluent for the Uniform sampling op with given low and high parameters.

        Args:
            low: The low parameter of the Uniform distribution.
            high: The high parameter of the Uniform distribution.
            batch_size: The size of the batch (optional).

        Returns:
            The Uniform distribution and a TensorFluent sample drawn from the distribution.

        Raises:
            ValueError: If parameters do not have the same scope.
        '''
        if low.scope != high.scope:
            raise ValueError('Uniform distribution: parameters must have same scope!')
        dist = tf.distributions.Uniform(low.tensor, high.tensor)
        batch = low.batch or high.batch
        if not batch and batch_size is not None:
            t = dist.sample(batch_size)
            batch = True
        else:
            t = dist.sample()
        scope = low.scope.as_list()
        return (dist, TensorFluent(t, scope, batch=batch))


Instruction:
Here you have a function in Python 3, explain what it does
def Normal(cls,
            mean: 'TensorFluent', variance: 'TensorFluent',
            batch_size: Optional[int] = None) -> Tuple[Distribution, 'TensorFluent']:
        '''Returns a TensorFluent for the Normal sampling op with given mean and variance.

        Args:
            mean: The mean parameter of the Normal distribution.
            variance: The variance parameter of the Normal distribution.
            batch_size: The size of the batch (optional).

        Returns:
            The Normal distribution and a TensorFluent sample drawn from the distribution.

        Raises:
            ValueError: If parameters do not have the same scope.
        '''
        if mean.scope != variance.scope:
            raise ValueError('Normal distribution: parameters must have same scope!')
        loc = mean.tensor
        scale = tf.sqrt(variance.tensor)
        dist = tf.distributions.Normal(loc, scale)
        batch = mean.batch or variance.batch
        if not batch and batch_size is not None:
            t = dist.sample(batch_size)
            batch = True
        else:
            t = dist.sample()
        scope = mean.scope.as_list()
        return (dist, TensorFluent(t, scope, batch=batch))

Response: Returns a TensorFluent for the Normal sampling op with given mean and variance.


Instruction:
Make a summary of the following Python 3 code
def Gamma(cls,
            shape: 'TensorFluent',
            scale: 'TensorFluent',
            batch_size: Optional[int] = None) -> Tuple[Distribution, 'TensorFluent']:
        '''Returns a TensorFluent for the Gamma sampling op with given shape and scale parameters.

        Args:
            shape: The shape parameter of the Gamma distribution.
            scale: The scale parameter of the Gamma distribution.
            batch_size: The size of the batch (optional).

        Returns:
            The Gamma distribution and a TensorFluent sample drawn from the distribution.

        Raises:
            ValueError: If parameters do not have the same scope.
        '''
        if shape.scope != scale.scope:
            raise ValueError('Gamma distribution: parameters must have same scope!')
        concentration = shape.tensor
        rate = 1 / scale.tensor
        dist = tf.distributions.Gamma(concentration, rate)
        batch = shape.batch or scale.batch
        if not batch and batch_size is not None:
            t = dist.sample(batch_size)
            batch = True
        else:
            t = dist.sample()
        scope = shape.scope.as_list()
        return (dist, TensorFluent(t, scope, batch=batch))

Response: Returns a TensorFluent for the Gamma sampling op with given shape and scale parameters.


Instruction:
How would you implement a function in Python 3 that
returns a TensorFluent for the Exponential sampling op with given mean parameter.

Response:
def Exponential(cls,
            mean: 'TensorFluent',
            batch_size: Optional[int] = None) -> Tuple[Distribution, 'TensorFluent']:
        '''Returns a TensorFluent for the Exponential sampling op with given mean parameter.

        Args:
            mean: The mean parameter of the Exponential distribution.
            batch_size: The size of the batch (optional).

        Returns:
            The Exponential distribution and a TensorFluent sample drawn from the distribution.
        '''
        rate = 1 / mean.tensor
        dist = tf.distributions.Exponential(rate)
        batch = mean.batch
        if not batch and batch_size is not None:
            t = dist.sample(batch_size)
            batch = True
        else:
            t = dist.sample()
        scope = mean.scope.as_list()
        return (dist, TensorFluent(t, scope, batch=batch))


Instruction:
Can you tell what is the following Python 3 function doing
def stop_gradient(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a copy of the input fluent with stop_gradient at tensor level.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent that stops backpropagation of gradient computations.
        '''
        scope = x.scope.as_list()
        batch = x.batch
        return TensorFluent(tf.stop_gradient(x.tensor), scope, batch)

Response: Returns a copy of the input fluent with stop_gradient at tensor level.


Instruction:
Can you tell what is the following Python 3 function doing
def stop_batch_gradient(cls, x: 'TensorFluent', stop_batch: tf.Tensor) -> 'TensorFluent':
        '''Returns a copy of the inputs fluent with stop_gradient applied at batch level.

        Args:
            x: The input fluent.
            stop_batch: A boolean tf.Tensor with shape=(batch_size, ...)

        Returns:
            A TensorFluent that conditionally stops backpropagation of gradient computations.
        '''
        scope = x.scope.as_list()
        batch = x.batch
        tensor = tf.where(stop_batch, tf.stop_gradient(x.tensor), x.tensor)
        return TensorFluent(tensor, scope, batch)

Response: Returns a copy of the fluent with stop_gradient applied at batch level.


Instruction:
Given the following Python 3 function, write the documentation
def abs(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the abs function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the abs function.
        '''
        return cls._unary_op(x, tf.abs, tf.float32)

Response: Returns a TensorFluent for the abs function.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def exp(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the exp function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the exp function.
        '''
        return cls._unary_op(x, tf.exp, tf.float32)

Response: Returns a TensorFluent for the exp function.


Instruction:
Implement a Python 3 function for
returning a TensorFluent for the log function.

Response:
def log(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the log function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the log function.
        '''
        return cls._unary_op(x, tf.log, tf.float32)


Instruction:
Can you implement a function in Python 3 that
returns a TensorFluent for the sqrt function.

Response:
def sqrt(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the sqrt function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the sqrt function.
        '''
        return cls._unary_op(x, tf.sqrt, tf.float32)


Instruction:
How would you code a function in Python 3 to
return a TensorFluent for the cos function.

Response:
def cos(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the cos function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the cos function.
        '''
        return cls._unary_op(x, tf.cos, tf.float32)


Instruction:
Can you tell what is the following Python 3 function doing
def sin(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the sin function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the sin function.
        '''
        return cls._unary_op(x, tf.sin, tf.float32)

Response: Returns a TensorFluent for the sin function.


Instruction:
Write a Python 3 script for
returning a TensorFluent for the tan function.

Response:
def tan(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the tan function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the tan function.
        '''
        return cls._unary_op(x, tf.tan, tf.float32)


Instruction:
Create a Python 3 function for
returning a TensorFluent for the acos function.

Response:
def acos(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the arccos function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the arccos function.
        '''
        return cls._unary_op(x, tf.acos, tf.float32)


Instruction:
How would you code a function in Python 3 to
return a TensorFluent for the arcsin function.

Response:
def asin(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the arcsin function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the arcsin function.
        '''
        return cls._unary_op(x, tf.asin, tf.float32)


Instruction:
Explain what the following Python 3 code does
def atan(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the arctan function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the arctan function.
        '''
        return cls._unary_op(x, tf.atan2, tf.float32)

Response: Returns a TensorFluent for the arctan function.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def round(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the round function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the round function.
        '''
        return cls._unary_op(x, tf.round, tf.float32)

Response: Returns a TensorFluent for the round function.


Instruction:
Make a summary of the following Python 3 code
def ceil(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the ceil function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the ceil function.
        '''
        return cls._unary_op(x, tf.ceil, tf.float32)

Response: Returns a TensorFluent for the ceil function.


Instruction:
Given the following Python 3 function, write the documentation
def floor(cls, x: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the floor function.

        Args:
            x: The input fluent.

        Returns:
            A TensorFluent wrapping the floor function.
        '''
        return cls._unary_op(x, tf.floor, tf.float32)

Response: Returns a TensorFluent for the floor function.


Instruction:
Write a Python 3 function that can
return a TensorFluent for the pow function.

Response:
def pow(cls, x: 'TensorFluent', y: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the pow function.TensorFluent

        Args:
            x: The first operand.
            y: The second operand.

        Returns:
            A TensorFluent wrapping the pow function.
        '''
        return cls._binary_op(x, y, tf.pow, tf.float32)


Instruction:
Can you implement a function in Python 3 that
returns a TensorFluent for the maximum function.

Response:
def max(cls, x: 'TensorFluent', y: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the maximum function.TensorFluent

        Args:
            x: The first operand.
            y: The second operand.

        Returns:
            A TensorFluent wrapping the maximum function.
        '''
        return cls._binary_op(x, y, tf.maximum, tf.float32)


Instruction:
How would you code a function in Python 3 to
return a TensorFluent for the minimum function.

Response:
def min(cls, x: 'TensorFluent', y: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the minimum function.

        Args:
            x: The first operand.
            y: The second operand.

        Returns:
            A TensorFluent wrapping the minimum function.
        '''
        return cls._binary_op(x, y, tf.minimum, tf.float32)


Instruction:
Create a Python 3 function to
return a TensorFluent for the if - then - else control op.

Response:
def if_then_else(cls,
            condition: 'TensorFluent',
            true_case: 'TensorFluent',
            false_case: 'TensorFluent') -> 'TensorFluent':
        '''Returns a TensorFluent for the control op if-then-else.

        Args:
            condition: Boolean fluent for the if condition.
            true_case: Fluent returned in the true clause.
            false_case: Fluent returned in the false clause.

        Returns:
            A TensorFluent wrapping the if-then-else control statement.

        Raises:
            ValueError: If cases don't have same shape.
        '''
        true = TensorFluent.constant(True, tf.bool)
        false = TensorFluent.constant(False, tf.bool)
        ite = (condition == true) * true_case + (condition == false) * false_case
        if true_case.dtype == tf.bool and false_case.dtype == tf.bool:
            ite = ite.cast(tf.bool)
        return ite