In short: no, you cannot include GPL and non-GPL code in the same script.

The long answer: yes, but only if you know exactly what you are doing and aren’t breaking the spirit of the GPL. My understanding is:

If you incorporate GPL licensed things into your software, those pieces must stay licensed under the GPL. The means: you must provide copies of those “modules” to anyone who asks for them. If you modified them, you must provide the modified copies. Finally, you have to include a copy of the GPL for those parts of your application when distributing your application. There is a minor misunderstanding among some people I’ve talked to that if you use GPL licensed software, your entire application defaults to a GPL license. This is not true.

The GPL makes a few notable exceptions. If you run software in a separate process it constitutes a separate program. The implication here is that you may interface with GPL software free from the binds of the GPL so long as the exchange is limited to message passing (IPC) and not direct linking (updating the PC and jumping into GPL land). A client to a server running GPL software is not bound by the GPL. Generally, a copyright (not EULA) license pertaining to a software work itself does/can not cover the output of the program to which it applies.

Additionally, the GPL allows for aggregate works. Aggregate works are covered in section 5 of the GPL-v3:

A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
“aggregate” if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation’s users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

Note that an aggregate work does not refer to a software that’s linked against a GPL component. As the GPL explicitly states, if any linking occurs (unless excepted either by the LGPL or explicitly such as with the system library exception) to software covered by the GPL, then the client work becomes GPL. So if the code ends up in the same binary or runs in the same process such that functions exposed are invoked directly, it generally must follow the GPL.

This is where it gets interesting. I have no idea if this would hold up in court, but based on my reading, it seems plausible that a GPL component and a non-GPL component could execute within the same process so long as one does not directly invoke the other. In other words, if they only share a data model, I believe they can coexist. In any event, drawing a hard process boundary between two such components is never a bad idea.

For example, Viscosity is a VPN application that provides a configuration interface for an aggregate OpenVPN client. Viscosity’s user interface is not covered by the GPL as it simply generates configuration data for OpenVPN and does not link against OpenVPN or do anything other than (instruct the system to) invoke the binary in its entirety. However, in order to make the integration more smooth, Viscosity also ships a patched version of OpenVPN. The patches they apply and resulting binary work derived from OpenVPN is covered under the GPL.

The other route is a SAAS model. Don’t even sell the software but sell the services it provides (and related support for those services). This is, in my opinion, the most popular model currently. In this model, your intellectual property (often, business model) is not the software (IP is irrelevant). You write the software, and then you become the best provider of its services to your customers. This is how Github, Bitbucket, etc. work.