def webCheck(website):

        try:
                print parse(website, rule='IRI')
                return True        
        except:
                return False

def clientfunc(connection, addr):
    print "Got connection from ", addr
    connection.send("Server up and running")
    while True:
        connection.send("Ready for another url")
        valid = True
        url_recieved = c.recv(1024)
        try:
            parse(url_recieved, rule="IRI")
        except Exception as e:
            valid = False
        if valid:
            url_recieved = url_recieved.split('/')[2]
            print "Do you want to write URL:", url_recieved, "to config file"
            print "for the node", addr
            response = raw_input("(yes/no):")
            if response == 'yes':
                fp = open("user.action", 'a')
                fp.write(url_recieved)
                fp.write("\n")
                print "URL written to the file user.action"
                print "Done"
                connection.send("The URL is accepted")
                fp.close()
            else:
                print "URL not added"
                print "Message sent to client"
                connection.send("The URL is blocked by admin")
        else:
            connection.send("The URL is not valid")
            pass
    connection.close()

 def insert_organization(self, data):
     try:
         parse(data['id'], rule='IRI')
         a = URIRef(data['id'])
     except ValueError:
         a = AOP[data['id']]
     self.sparql.add((a, RDF.type, FOAF.Organization))
     self.sparql.add((a, FOAF.name, Literal(data['label'])))
     return 'OK'

 def insert_place(self, data):
     try:
         parse(data['id'], rule='IRI')
         a = URIRef(data['id'])
     except ValueError:
         a = DBPEDIA[data['id']]
     self.sparql.add((a, RDF.type, DBPEDIA.Place))
     self.sparql.add((a, RDFS.label, Literal(data['label'])))
     return 'OK'

 def insert_concept(self, data):
     try:
         parse(data['id'], rule='IRI')
         a = URIRef(data['id'])
     except ValueError:
         a = BNCF[data['id']]
     self.sparql.add((a, RDF.type, SKOS.Concept))
     self.sparql.add((a, RDFS.label, Literal(data['label'])))
     return 'OK'

def set_from_url(record, return_data):
    if len(record['SOURCEURL']) > 0:
        try:
            parse(record['SOURCEURL'], rule='IRI')
            return_data['fromURL'] = record['SOURCEURL']
        except:
            pass

    return return_data

def validate_url(url):
    """
    Validates URL (actually, IRIs).
    """
    try:
        rfc3987.parse(url, rule="IRI")
    except:
        return False

    return True

def is_url(url):
    """
    Returns True if `url` is an IRI as specified in the RFC 3987
    (https://www.ietf.org/rfc/rfc3987.txt)
    """
    try:
        rfc3987.parse(url, rule="IRI")
        return True
    except ValueError:
        logger.warning("%s is not a valid url.", url)
        return False

 def insert_author(self, author):
     try:
         parse(author['author_id'], rule='IRI')
         a = author['author_id']
     except ValueError:
         a = AOP[author['author_id']]
     self.sparql.add((a, RDF.type, FOAF.Person))
     self.sparql.add((a, FOAF.name, Literal(author['author_fullname'])))
     if 'author_email' in author:
         self.sparql.add((a, SCHEMA.email, Literal(author['author_email'])))
     return 'OK'

def guess_server_url(
    url: str,
    login_page: str = Options.startup_page,
    proxy: "Proxy" = None,
    timeout: int = 5,
) -> str:
    """
    Guess the complete server URL given an URL (either an IP address,
    a simple domain name or an already complete URL).

    :param url: The server URL (IP, domain name, full URL).
    :param login_page: The Drive login page.
    :param int timeout: Timeout for each and every request.
    :return: The complete URL.
    """
    import requests
    import rfc3987

    from requests.exceptions import SSLError

    kwargs: Dict[str, Any] = {
        "timeout": timeout,
        "verify": Options.ca_bundle or not Options.ssl_no_verify,
    }
    for new_url in compute_urls(url):
        try:
            rfc3987.parse(new_url, rule="URI")
            log.debug(f"Testing URL {new_url!r}")
            full_url = f"{new_url}/{login_page}"
            if proxy:
                kwargs["proxies"] = proxy.settings(url=full_url)
            with requests.get(full_url, **kwargs) as resp:
                resp.raise_for_status()
                if resp.status_code == 200:
                    log.debug(f"Found URL: {new_url}")
                    return new_url
        except requests.HTTPError as exc:
            if exc.response.status_code in {401, 403}:
                # When there is only Web-UI installed, the code is 401.
                log.debug(f"Found URL: {new_url}")
                return new_url
        except SSLError as exc:
            if "CERTIFICATE_VERIFY_FAILED" in str(exc):
                raise InvalidSSLCertificate()
        except (ValueError, requests.RequestException):
            log.debug(f"Bad URL: {new_url}")
        except Exception:
            log.exception("Unhandled error")

    if not url.lower().startswith("http"):
        return ""
    return url

    def validate(self, value):
        """Check that the URL is valid, and optionally accessible."""
        try:
            parse(value)
        except ValueError:
            print value
            self.error("Value is not a valid URL")

        if self.verify_exists:
            try:
                get(value)
            except:
                self.error("The URL appears to be inaccessible")

 def to_b64(self, image_filename, *args):
     """ Returns a tuple with (b64content, imgtype) where:
         - b64content is a base64 representation of the input file
         - imgtype is the image type as detected by imghdr
     """
     self.logger.debug('Converting image %s to base64', image_filename)
     self.logger.debug('Current directory %s', os.path.abspath(os.curdir))
     try:
         img_info = parse(image_filename, rule='IRI')
         extension = img_info['path'].split('.')[-1]
         content = urlopen(image_filename)
     except ValueError:  # not a valid IRI, assume local file
         self.logger.debug("Image '%s' doesn't have a valid URL, "
                           "assuming local", image_filename)
         try:
             extension = imghdr.what(image_filename)
             if extension is None:
                 self.logger.debug('Image extension not detected, skipping')
                 return ''
             content = open(image_filename, 'rb')
         except (IOError, AttributeError, TypeError):
             return ''
     except (HTTPError, URLError, TypeError):
         return ''
     txt = 'data:image/{};base64,\n{}'.format(extension,
                                              content.read().encode('base64'
                                                                    )
                                              )
     content.close()
     return txt

def launch_the_stream():
    parser = create_parser()
    if len(argv) == 1:
        parser.print_help()
        exit(1)

    arguments = parser.parse_args()

    rv = 0
    statistics = UserStat(APPLICATION_NAME, STAT_FILE_NAME)
    statistics.load()
    nicknames = Nicknames(APPLICATION_NAME, ALIAS_FILE_NAME)
    nicknames.load()
    if arguments.stat:
        print(str(statistics))
    elif arguments.aliases:
        print(str(nicknames))
    elif arguments.clear:
        trimmed = statistics.fltr(lambda key, value: value > int(arguments.clear))
        statistics.save()
        print("Statistics cleared: {0}".format(trimmed))
    elif (arguments.let and len(arguments.let) == 2):
        (nick, URL) = arguments.let
        nicknames.assign(nick, URL)
        # Extract the last part of URL path as a streamer nick
        streamer = [x for x in parse(URL)['path'].split('/') if x][-1]
        trimmed = statistics.fltr(lambda key, value: streamer not in key)
        statistics.save()
        nicknames.save()
        print("{0} was assigned to {1}; Statistics cleared: {2}".format(nick, URL, trimmed))
    else:
        rv = assemble_command(arguments, statistics, nicknames)

    return rv

 def is_valid_uri(instance):
     if not isinstance(instance, six.string_types):
         return True
     uri = urlparse(instance)
     query = urlencode(parse_qsl(unquote(uri.query.encode('utf-8'))))
     return rfc3987.parse(uri._replace(query=query).geturl(),
                          rule='URI')

def serialize_fe(fe, reified, wiki_title, add_triple, format):
    # The FE predicate takes the FE label
    p1 = _uri_for('FE', 'predicate', fe['FE'])

    # The FE object takes the linked entity URI and/or the literal
    le_uri = fe.get('uri')
    literal = fe.get('literal')
    
    if le_uri:  # It's a URI
        wiki_title = quote(le_uri.split('/')[-1].encode('utf8'))
        o1 = NAMESPACES['resource'] + wiki_title
        parsed = parse(o1, rule='URI_reference')  # URI sanity check
        assert add_triple(reified, p1, o1)

    if literal:  # It's a literal
        if type(literal) in {str, unicode}:
            assert add_triple(reified, p1, literal)

        elif type(literal) == dict:

            if 'duration' in literal:
                assert add_triple(reified, p1, literal['duration'])

            if 'start' in literal:
                assert add_triple(reified, '%sstartYear' % NAMESPACES['ontology'],
                                  literal['start'])

            if 'end' in literal:
                assert add_triple(reified, '%sendYear' % NAMESPACES['ontology'],
                                  literal['end'])

        else:
            raise Exception("Don't know how to serialize: " + repr(literal))

    def execute(self, obj):
        if not isinstance(obj, str):
            raise TypeError('\'{}\' is not of type str.'.format(obj))

        parsed = self._parse(obj)
        parsed = self._process(**parsed)
        return rfc3987.parse(rfc3987.compose(**parsed))

def uri_validator(value, **kwargs):
    try:
        parts = rfc3987.parse(value, rule='URI')
    except ValueError:
        raise ValidationError(MESSAGES['format']['invalid_uri'].format(value))

    if not parts['scheme'] or not parts['authority']:
        raise ValidationError(MESSAGES['format']['invalid_uri'].format(value))

def test_doi_link(doi, result):
    if isinstance(result, Exception):
        with pytest.raises(type(result)) as e:
            DOILink().execute(doi)
        assert e.value.args == result.args
    else:
        assert rfc3987.parse(result)  # Extra URL validation
        assert DOILink().execute(doi)['IRI'] == result

def test_ark_link(ark_id, result):
    if isinstance(result, Exception):
        with pytest.raises(type(result)) as e:
            ARKLink().execute(ark_id)
        assert e.value.args == result.args
    else:
        assert rfc3987.parse(result)  # Extra URL validation
        assert ARKLink().execute(ark_id)['IRI'] == result

def test_urn_link(urn, result):
    if isinstance(result, Exception):
        with pytest.raises(type(result)) as e:
            URNLink().execute(urn)
        assert e.value.args == result.args
    else:
        assert rfc3987.parse(result)  # Extra URL validation
        assert URNLink().execute(urn)['IRI'] == result