import os
import sys
import types
-import urllib
-import urllib2
+import six
try:
import json
sequences = library.get('index_sequence', None)
if sequences is None:
return []
- elif (type(sequences) in types.StringTypes and
- sequences.lower().startswith('err')):
+ elif isinstance(sequences, six.string_types):
shared['Index'] = ''
shared['SampleProject'] = library['library_id']
return [shared]
- elif (type(sequences) == types.DictType):
+ elif isinstance(sequences, dict):
pooled = []
multiplex_ids = sequences.keys()
multiplex_ids.sort(key=natural_sort_key)
import types
import re
import sys
+import six
from six.moves.urllib.parse import urljoin, urlparse
import RDF
Scan through a list of directories for sequence like files
"""
sequences = []
- if type(dirs) in types.StringTypes:
+ if isinstance(dirs, six.string_types):
raise ValueError("You probably want a list or set, not a string")
for d in dirs:
import os
import logging
import re
-import types
from pprint import pprint
from lxml import html
value = getattr(self, variable_name)
if value is None:
continue
- # it looks like a sequence
- elif type(value) in (types.TupleType, types.ListType):
+ elif isinstance(value, (tuple, list)):
element = make_mean_range_element(
lane_result,
tag,
from pprint import pformat,pprint
import sys
import types
+import six
from six.moves.urllib.parse import urljoin, urlparse
from htsworkflow.pipelines.sequences import scan_for_sequences, \
self.cycle = fromTypedNode(result['cycle'])
self.lane_number = fromTypedNode(result['lane_number'])
self.read = fromTypedNode(result['read'])
- if type(self.read) in types.StringTypes:
+ if isinstance(self.read, six.string_types):
self.read = 1
self.library = result['library']
self.library_id = fromTypedNode(result['library_id'])
"""Parse UCSC DAF File
"""
+import collections
import logging
import os
from pprint import pformat
else:
self.model = get_model()
- if hasattr(daf_file, 'next'):
+ if isinstance(daf_file, collections.Iterable):
# its some kind of stream
self.daf = daf_file.read()
else:
import jsonschema
import os
import requests
-import types
+import six
from six.moves.urllib.parse import urljoin, urlparse, urlunparse
LOGGER = logging.getLogger(__name__)
and I needed a way to properly compute a the correct base URL.
'''
# pretend strings aren't iterable
- if type(obj) in types.StringTypes:
+ if isinstance(obj, six.string_types):
return
# recurse on container types
obj_type = obj.get('@type')
if not obj_type:
raise ValueError('None type')
- if type(obj_type) in types.StringTypes:
+ if isinstance(obj_type, six.string_types):
raise ValueError('@type should be a list, not a string')
if not isinstance(obj_type, collections.Sequence):
raise ValueError('@type is not a sequence')
import collections
from datetime import datetime
from glob import glob
+import six
from six.moves import urllib
import logging
import os
node = None
if value is None:
node = RDF.Node()
- elif type(value) in types.StringTypes:
+ elif isinstance(value, six.string_types):
node = RDF.Node(uri_string=value)
elif isinstance(value, RDF.Node):
node = value
def toTypedNode(value, language="en"):
"""Convert a python variable to a RDF Node with its closest xsd type
"""
- if type(value) == types.BooleanType:
+ if isinstance(value, bool):
value_type = xsdNS['boolean'].uri
if value:
value = u'1'
else:
value = u'0'
- elif type(value) in (types.IntType, types.LongType):
+ elif isinstance(value, int):
value_type = xsdNS['decimal'].uri
value = unicode(value)
- elif type(value) == types.FloatType:
+ elif isinstance(value, float):
value_type = xsdNS['float'].uri
value = unicode(value)
elif isinstance(value, datetime):
def load_into_model(model, parser_name, path, ns=None):
- if type(ns) in types.StringTypes:
+ if isinstance(ns, six.string_types):
ns = RDF.Uri(ns)
if isinstance(path, RDF.Node):
def fixup_namespace(ns):
if ns is None:
ns = RDF.Uri("http://localhost/")
- elif type(ns) in types.StringTypes:
+ elif isinstance(ns, six.string_types):
ns = RDF.Uri(ns)
elif not(isinstance(ns, RDF.Uri)):
errmsg = "Namespace should be string or uri not {0}"
import os
import types
from unittest import TestCase
-
from datetime import datetime
+import six
from htsworkflow.util.rdfhelp import \
add_default_schemas, \
s = "Argh matey"
node = toTypedNode(s)
self.assertEqual(fromTypedNode(node), s)
- self.assertEqual(type(fromTypedNode(node)), types.UnicodeType)
+ self.assertTrue(isinstance(fromTypedNode(node), six.text_type))
def test_blank_or_uri_blank(self):
node = blankOrUri()
def test_unicode_node_roundtrip(self):
literal = u'\u5927'
roundtrip = fromTypedNode(toTypedNode(literal))
- self.assertEqual(roundtrip, literal)
- self.assertEqual(type(roundtrip), types.UnicodeType)
+ self.assertTrue(isinstance(roundtrip, six.text_type))
def test_datetime_no_microsecond(self):
dateTimeType = xsdNS['dateTime'].uri
from django.core import urlresolvers
from django.db.models.signals import pre_save, post_save
from django.db import connection
+import six
logger = logging.getLogger(__name__)
sequences = self.index_sequences()
if sequences is None:
return ""
- if type(sequences) in types.StringTypes:
+ if isinstance(sequences, six.string_types):
return sequences
multiplex_ids = sequences.keys()
multiplex_ids.sort()