From 6e915d8a9ac5474c20482751ab6d24e6ce13aec9 Mon Sep 17 00:00:00 2001 From: parmentelat Date: Tue, 11 Dec 2018 09:39:23 +0100 Subject: [PATCH] StringTypes has gone --- PLC/AddressTypes.py | 5 +-- PLC/Filter.py | 7 ++-- PLC/GPG.py | 7 ++-- PLC/InitScripts.py | 5 +-- PLC/Interfaces.py | 11 +++-- PLC/LeaseFilter.py | 9 ++-- PLC/Method.py | 10 ++--- PLC/Methods/ResetPassword.py | 8 ++-- PLC/Methods/RetrieveSlicePersonKeys.py | 16 ++++---- PLC/Methods/RetrieveSliceSliverKeys.py | 34 ++++++++------- PLC/NodeGroups.py | 6 +-- PLC/Nodes.py | 5 +-- PLC/PCUTypes.py | 6 +-- PLC/Parameter.py | 16 ++++---- PLC/Peers.py | 5 +-- PLC/Persons.py | 5 +-- PLC/PostgreSQL.py | 9 ++-- PLC/Roles.py | 5 +-- PLC/Sessions.py | 5 +-- PLC/Sites.py | 5 +-- PLC/Slices.py | 5 +-- PLC/Table.py | 9 ++-- PLC/TagTypes.py | 6 +-- PLC/Timestamp.py | 57 +++++++++++++++----------- 24 files changed, 117 insertions(+), 139 deletions(-) diff --git a/PLC/AddressTypes.py b/PLC/AddressTypes.py index acc0025..6423129 100644 --- a/PLC/AddressTypes.py +++ b/PLC/AddressTypes.py @@ -5,7 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes from PLC.Faults import * from PLC.Parameter import Parameter from PLC.Filter import Filter @@ -54,7 +53,7 @@ class AddressTypes(Table): if isinstance(address_type_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in address_type_filter if isinstance(x, int)] - strs = [x for x in address_type_filter if isinstance(x, StringTypes)] + strs = [x for x in address_type_filter if isinstance(x, str)] address_type_filter = Filter(AddressType.fields, {'address_type_id': ints, 'name': strs}) sql += " AND (%s) %s" % address_type_filter.sql(api, "OR") elif isinstance(address_type_filter, dict): @@ -63,7 +62,7 @@ class AddressTypes(Table): elif isinstance(address_type_filter, int): address_type_filter = Filter(AddressType.fields, {'address_type_id': address_type_filter}) sql += " AND (%s) %s" % address_type_filter.sql(api, "AND") - elif isinstance(address_type_filter, StringTypes): + elif isinstance(address_type_filter, str): address_type_filter = Filter(AddressType.fields, {'name': address_type_filter}) sql += " AND (%s) %s" % address_type_filter.sql(api, "AND") else: diff --git a/PLC/Filter.py b/PLC/Filter.py index 5c45572..41f89a6 100644 --- a/PLC/Filter.py +++ b/PLC/Filter.py @@ -1,7 +1,6 @@ # # Thierry Parmentelat - INRIA # -from types import StringTypes import time from PLC.Faults import * @@ -70,9 +69,9 @@ class Filter(Parameter, dict): * similarly the two special keys below allow to change the semantics of multi-keys filters * '-AND' : select rows that match ALL the criteria (default) * '-OR' : select rows that match ANY criteria - The value attached to these keys is ignored. + The value attached to these keys is ignored. Please note however that because a Filter is a dict, you cannot provide two criteria on a given key. - + Here are a few realistic examples @@ -167,7 +166,7 @@ class Filter(Parameter, dict): if value is None: operator = "IS" value = "NULL" - elif isinstance(value, StringTypes) and \ + elif isinstance(value, str) and \ (value.find("*") > -1 or value.find("%") > -1): operator = "ILIKE" # insert *** in pattern instead of either * or % diff --git a/PLC/GPG.py b/PLC/GPG.py index 270bc45..4a99884 100644 --- a/PLC/GPG.py +++ b/PLC/GPG.py @@ -11,7 +11,6 @@ import os import xmlrpc.client import shutil -from types import StringTypes from io import StringIO from subprocess import Popen, PIPE, call from tempfile import NamedTemporaryFile, mkdtemp @@ -29,7 +28,7 @@ def canonicalize(args, methodname = None, methodresponse = False): xml = xmlrpc.client.dumps(args, methodname, methodresponse, encoding = 'utf-8', allow_none = 1) dom = etree.fromstring(xml) canonical=etree.tostring(dom) - # pre-f20 version was using Canonicalize from PyXML + # pre-f20 version was using Canonicalize from PyXML # from xml.dom.ext import Canonicalize # Canonicalize(), though it claims to, does not encode unicode # nodes to UTF-8 properly and throws an exception unless you write @@ -76,7 +75,7 @@ def gpg_sign(args, secret_keyring, keyring, methodname = None, methodresponse = """ # Accept either an opaque string blob or a Python tuple - if isinstance(args, StringTypes): + if isinstance(args, str): message = args elif isinstance(args, tuple): message = canonicalize(args, methodname, methodresponse) @@ -123,7 +122,7 @@ def gpg_verify(args, key, signature = None, methodname = None, methodresponse = """ # Accept either an opaque string blob or a Python tuple - if isinstance(args, StringTypes): + if isinstance(args, str): message = args else: message = canonicalize(args, methodname, methodresponse) diff --git a/PLC/InitScripts.py b/PLC/InitScripts.py index f7cb0b5..18a685f 100644 --- a/PLC/InitScripts.py +++ b/PLC/InitScripts.py @@ -5,7 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes from PLC.Faults import * from PLC.Parameter import Parameter from PLC.Filter import Filter @@ -55,7 +54,7 @@ class InitScripts(Table): if isinstance(initscript_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in initscript_filter if isinstance(x, int)] - strs = [x for x in initscript_filter if isinstance(x, StringTypes)] + strs = [x for x in initscript_filter if isinstance(x, str)] initscript_filter = Filter(InitScript.fields, {'initscript_id': ints, 'name': strs }) sql += " AND (%s) %s" % initscript_filter.sql(api, "OR") elif isinstance(initscript_filter, dict): @@ -64,7 +63,7 @@ class InitScripts(Table): elif isinstance(initscript_filter, int): initscript_filter = Filter(InitScript.fields, {'initscript_id': initscript_filter}) sql += " AND (%s) %s" % initscript_filter.sql(api, "AND") - elif isinstance(initscript_filter, StringTypes): + elif isinstance(initscript_filter, str): initscript_filter = Filter(InitScript.fields, {'name': initscript_filter}) sql += " AND (%s) %s" % initscript_filter.sql(api, "AND") else: diff --git a/PLC/Interfaces.py b/PLC/Interfaces.py index 07c351d..5b0f70e 100644 --- a/PLC/Interfaces.py +++ b/PLC/Interfaces.py @@ -5,7 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes import socket import struct @@ -30,7 +29,7 @@ def valid_ipv6(ip): ip = socket.inet_ntop(socket.AF_INET6, socket.inet_pton(socket.AF_INET6, ip)) return True except socket.error: - return False + return False def valid_ip(ip): return valid_ipv4(ip) or valid_ipv6(ip) @@ -59,7 +58,7 @@ def in_same_network_ipv6(address1, address2, netmask): def in_same_network(address1, address2, netmask): return in_same_network_ipv4(address1, address2, netmask) or \ - in_same_network_ipv6(address1, address2, netmask) + in_same_network_ipv6(address1, address2, netmask) class Interface(Row): """ @@ -258,7 +257,7 @@ class Interface(Row): ### need to cleanup ilinks self.api.db.do("DELETE FROM ilink WHERE src_interface_id=%d OR dst_interface_id=%d" % \ (self['interface_id'],self['interface_id'])) - + Row.delete(self) class Interfaces(Table): @@ -284,7 +283,7 @@ class Interfaces(Table): if isinstance(interface_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in interface_filter if isinstance(x, int)] - strs = [x for x in interface_filter if isinstance(x, StringTypes)] + strs = [x for x in interface_filter if isinstance(x, str)] interface_filter = Filter(Interface.fields, {'interface_id': ints, 'ip': strs}) sql += " AND (%s) %s" % interface_filter.sql(api, "OR") elif isinstance(interface_filter, dict): @@ -294,7 +293,7 @@ class Interfaces(Table): elif isinstance(interface_filter, int): interface_filter = Filter(Interface.fields, {'interface_id': [interface_filter]}) sql += " AND (%s) %s" % interface_filter.sql(api) - elif isinstance (interface_filter, StringTypes): + elif isinstance (interface_filter, str): interface_filter = Filter(Interface.fields, {'ip':[interface_filter]}) sql += " AND (%s) %s" % interface_filter.sql(api, "AND") else: diff --git a/PLC/LeaseFilter.py b/PLC/LeaseFilter.py index 20078fc..df91409 100644 --- a/PLC/LeaseFilter.py +++ b/PLC/LeaseFilter.py @@ -6,7 +6,6 @@ import time import calendar -from types import StringTypes from PLC.Faults import * from PLC.Filter import Filter from PLC.Parameter import Parameter, Mixed @@ -83,7 +82,7 @@ class LeaseFilter (Filter): # hooks for the local fields def sql_alive(self, alive): - if isinstance(alive, int) or isinstance(alive, StringTypes): + if isinstance(alive, int) or isinstance(alive, str): # the lease is alive at that time if from <= alive <= until alive = LeaseFilter.quote(alive) return LeaseFilter.sql_time_in_range(alive, 't_from', 't_until') @@ -97,7 +96,7 @@ class LeaseFilter (Filter): .format(alive)) def sql_clip(self, clip): - if isinstance(clip, int) or isinstance(clip, StringTypes): + if isinstance(clip, int) or isinstance(clip, str): start = LeaseFilter.quote(clip) return LeaseFilter.sql_timeslot_after('t_from', 't_until', start) elif isinstance(clip, tuple): @@ -109,7 +108,7 @@ class LeaseFilter (Filter): raise PLCInvalidArgument("LeaseFilter: clip field {}" .format(clip)) - # the whole key to implementing day is to compute today's beginning + # the whole key to implementing day is to compute today's beginning def today_start(self): # a struct_time st = time.localtime() @@ -129,7 +128,7 @@ class LeaseFilter (Filter): else: self['clip'] = (today, today + nb_days * 24 * 3600) del self['day'] - + # preserve locally what belongs to us, hide it from the superclass # self.local is a dict local_key : user_value # self.negation is a dict local_key : string diff --git a/PLC/Method.py b/PLC/Method.py index 8e9fb20..81a1747 100644 --- a/PLC/Method.py +++ b/PLC/Method.py @@ -11,8 +11,6 @@ import os import time import pprint -from types import StringTypes - from PLC.Faults import * from PLC.Parameter import Parameter, Mixed, python_type, xmlrpc_type from PLC.Auth import Auth @@ -63,14 +61,14 @@ class Method (object): self.name = self.__class__.__name__ self.api = api - if caller: + if caller: # let a method call another one by propagating its caller self.caller=caller else: # Auth may set this to a Person instance (if an anonymous # method, will remain None). self.caller = None - + # API may set this to a (addr, port) tuple if known self.source = None @@ -335,7 +333,7 @@ class Method (object): # Strings are a special case. Accept either unicode or str # types if a string is expected. - if expected_type in StringTypes and isinstance(value, StringTypes): + if expected_type is str and isinstance(value, str): pass # Integers and long integers are also special types. Accept @@ -350,7 +348,7 @@ class Method (object): name) # If a minimum or maximum (length, value) has been specified - if expected_type in StringTypes: + if expected_type is str: if min is not None and \ len(value.encode(self.api.encoding)) < min: raise PLCInvalidArgument("%s must be at least %d bytes long" % (name, min)) diff --git a/PLC/Methods/ResetPassword.py b/PLC/Methods/ResetPassword.py index ca488a3..8036969 100644 --- a/PLC/Methods/ResetPassword.py +++ b/PLC/Methods/ResetPassword.py @@ -3,8 +3,6 @@ import base64 import time import urllib.request, urllib.parse, urllib.error -from types import StringTypes - from PLC.Logger import logger from PLC.Faults import * from PLC.Method import Method @@ -44,10 +42,10 @@ class ResetPassword(Method): def call(self, auth, person_id_or_email, verification_key = None, verification_expires = None): # Get account information # we need to search in local objects only - if isinstance (person_id_or_email,StringTypes): - filter={'email':person_id_or_email} + if isinstance (person_id_or_email, str): + filter = {'email': person_id_or_email} else: - filter={'person_id':person_id_or_email} + filter = {'person_id': person_id_or_email} filter['peer_id']=None persons = Persons(self.api, filter) if not persons: diff --git a/PLC/Methods/RetrieveSlicePersonKeys.py b/PLC/Methods/RetrieveSlicePersonKeys.py index e851fe2..0d55eb7 100644 --- a/PLC/Methods/RetrieveSlicePersonKeys.py +++ b/PLC/Methods/RetrieveSlicePersonKeys.py @@ -1,10 +1,8 @@ -from types import StringTypes - from PLC.Method import Method from PLC.Parameter import Parameter, Mixed from PLC.Filter import Filter from PLC.Auth import Auth -from PLC.Slices import Slice, Slices +from PLC.Slices import Slice, Slices from PLC.Persons import Person, Persons from PLC.Keys import Key, Keys from functools import reduce @@ -14,7 +12,7 @@ class RetrieveSlicePersonKeys(Method): This method exposes the public ssh keys for people in a slice It expects a slice name or id, and returns a dictionary on emails. This method is designed to help third-party software authenticate - users (e.g. the OMF Experiment Controller). + users (e.g. the OMF Experiment Controller). For this reason it is accessible with anonymous authentication. """ @@ -41,7 +39,7 @@ class RetrieveSlicePersonKeys(Method): # the people in the slice slice=Slices (self.api, slice_id_or_name, ['person_ids'])[0] slice_person_ids = slice['person_ids'] - + # if caller has not specified person_id, use slice_person_ids if 'person_id' not in person_filter: person_filter['person_id']=slice_person_ids @@ -51,17 +49,17 @@ class RetrieveSlicePersonKeys(Method): if not isinstance (caller_provided,list): caller_provided = [ caller_provided, ] person_filter['person_id'] = list ( set(caller_provided).intersection(slice_person_ids) ) - + def merge (l1,l2): return l1+l2 persons = Persons (self.api, person_filter, ['email','key_ids'] ) key_id_to_email_hash = \ - dict ( reduce ( merge , [ [ (kid,p['email']) for kid in p['key_ids']] for p in persons ] ) ) - + dict ( reduce ( merge , [ [ (kid,p['email']) for kid in p['key_ids']] for p in persons ] ) ) + all_key_ids = reduce (merge, [ p['key_ids'] for p in persons ] ) all_keys = Keys (self.api, all_key_ids) - + result={} for key in all_keys: key_id=key['key_id'] diff --git a/PLC/Methods/RetrieveSliceSliverKeys.py b/PLC/Methods/RetrieveSliceSliverKeys.py index 6cdf2a0..0e2f394 100644 --- a/PLC/Methods/RetrieveSliceSliverKeys.py +++ b/PLC/Methods/RetrieveSliceSliverKeys.py @@ -1,19 +1,17 @@ -from types import StringTypes - from PLC.Method import Method from PLC.Parameter import Parameter, Mixed from PLC.Filter import Filter from PLC.Auth import Auth from PLC.Nodes import Node, Nodes from PLC.SliceTags import SliceTag, SliceTags -from PLC.Slices import Slice, Slices +from PLC.Slices import Slice, Slices class RetrieveSliceSliverKeys(Method): """ This method exposes the public ssh keys for a slice's slivers. It expects a slice name or id, and returns a dictionary on hostnames. This method is designed to help third-party software authenticate - slivers (e.g. the OMF Experiment Controller). + slivers (e.g. the OMF Experiment Controller). For this reason it is accessible with anonymous authentication. """ @@ -34,28 +32,28 @@ class RetrieveSliceSliverKeys(Method): returns = Parameter (dict, " ssh keys hashed on hostnames") def call(self, auth, slice_id_or_name, node_filter=None): - + filter={} if isinstance(slice_id_or_name,int): - filter['slice_id']=slice_id_or_name - elif isinstance(slice_id_or_name,StringTypes): - filter['name']=slice_id_or_name - filter['tagname']='ssh_key' + filter['slice_id'] = slice_id_or_name + elif isinstance(slice_id_or_name, str): + filter['name'] = slice_id_or_name + filter['tagname'] = 'ssh_key' # retrieve only sliver tags - filter['~node_id']=None + filter['~node_id'] = None if node_filter: # make sure we only deal with local nodes - node_filter['peer_id']=None + node_filter['peer_id'] = None nodes = Nodes(self.api, node_filter, ['node_id']) - node_ids = [ node ['node_id'] for node in nodes ] - filter['node_id']=node_ids - + node_ids = [node['node_id'] for node in nodes] + filter['node_id'] = node_ids + # slice_tags don't expose hostname, sigh.. - slice_tags=SliceTags(self.api,filter,['node_id','tagname','value']) + slice_tags = SliceTags(self.api, filter, ['node_id', 'tagname', 'value']) node_ids = [st['node_id'] for st in slice_tags] # fetch nodes - nodes=Nodes(self.api,node_ids,['node_id','hostname']) + nodes = Nodes(self.api, node_ids, ['node_id', 'hostname']) # hash on node_id - nodes_hash=dict( [ (n['node_id'],n['hostname']) for n in nodes]) + nodes_hash = {n['node_id']: n['hostname'] for n in nodes} # return values hashed on hostname - return dict([ (nodes_hash[st['node_id']],st['value']) for st in slice_tags]) + return {nodes_hash[st['node_id']]: st['value'] for st in slice_tags} diff --git a/PLC/NodeGroups.py b/PLC/NodeGroups.py index 8f0a13e..abef32c 100644 --- a/PLC/NodeGroups.py +++ b/PLC/NodeGroups.py @@ -5,8 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes - from PLC.Faults import * from PLC.Parameter import Parameter, Mixed from PLC.Filter import Filter @@ -92,7 +90,7 @@ class NodeGroups(Table): if isinstance(nodegroup_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in nodegroup_filter if isinstance(x, int)] - strs = [x for x in nodegroup_filter if isinstance(x, StringTypes)] + strs = [x for x in nodegroup_filter if isinstance(x, str)] nodegroup_filter = Filter(NodeGroup.fields, {'nodegroup_id': ints, 'groupname': strs}) sql += " AND (%s) %s" % nodegroup_filter.sql(api, "OR") elif isinstance(nodegroup_filter, dict): @@ -101,7 +99,7 @@ class NodeGroups(Table): elif isinstance(nodegroup_filter, int): nodegroup_filter = Filter(NodeGroup.fields, {'nodegroup_id': nodegroup_filter}) sql += " AND (%s) %s" % nodegroup_filter.sql(api, "AND") - elif isinstance(nodegroup_filter, StringTypes): + elif isinstance(nodegroup_filter, str): nodegroup_filter = Filter(NodeGroup.fields, {'groupname': nodegroup_filter}) sql += " AND (%s) %s" % nodegroup_filter.sql(api, "AND") else: diff --git a/PLC/Nodes.py b/PLC/Nodes.py index efef4c1..6af9ee9 100644 --- a/PLC/Nodes.py +++ b/PLC/Nodes.py @@ -5,7 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes import re from PLC.Faults import * @@ -325,14 +324,14 @@ class Nodes(Table): if isinstance(node_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in node_filter if isinstance(x, int)] - strs = [x for x in node_filter if isinstance(x, StringTypes)] + strs = [x for x in node_filter if isinstance(x, str)] node_filter = Filter(Node.fields, {'node_id': ints, 'hostname': strs}) sql += " AND (%s) %s" % node_filter.sql(api, "OR") elif isinstance(node_filter, dict): allowed_fields=dict(list(Node.fields.items())+list(Node.tags.items())) node_filter = Filter(allowed_fields, node_filter) sql += " AND (%s) %s" % node_filter.sql(api, "AND") - elif isinstance (node_filter, StringTypes): + elif isinstance (node_filter, str): node_filter = Filter(Node.fields, {'hostname':node_filter}) sql += " AND (%s) %s" % node_filter.sql(api, "AND") elif isinstance (node_filter, int): diff --git a/PLC/PCUTypes.py b/PLC/PCUTypes.py index 50177d5..a34f29a 100644 --- a/PLC/PCUTypes.py +++ b/PLC/PCUTypes.py @@ -5,8 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes - from PLC.Faults import * from PLC.Parameter import Parameter from PLC.Table import Row, Table @@ -68,13 +66,13 @@ class PCUTypes(Table): if isinstance(pcu_type_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in pcu_type_filter if isinstance(x, int)] - strs = [x for x in pcu_type_filter if isinstance(x, StringTypes)] + strs = [x for x in pcu_type_filter if isinstance(x, str)] pcu_type_filter = Filter(PCUType.fields, {'pcu_type_id': ints, 'model': strs}) sql += " AND (%s) %s" % pcu_type_filter.sql(api, "OR") elif isinstance(pcu_type_filter, dict): pcu_type_filter = Filter(PCUType.fields, pcu_type_filter) sql += " AND (%s) %s" % pcu_type_filter.sql(api, "AND") - elif isinstance (pcu_type_filter, StringTypes): + elif isinstance (pcu_type_filter, str): pcu_type_filter = Filter(PCUType.fields, {'model':pcu_type_filter}) sql += " AND (%s) %s" % pcu_type_filter.sql(api, "AND") elif isinstance (pcu_type_filter, int): diff --git a/PLC/Parameter.py b/PLC/Parameter.py index 08352ff..6d20307 100644 --- a/PLC/Parameter.py +++ b/PLC/Parameter.py @@ -5,7 +5,7 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import * +# from types import * from PLC.Faults import * class Parameter: @@ -80,19 +80,19 @@ def xmlrpc_type(arg): arg_type = python_type(arg) - if arg_type == NoneType: + if arg_type is type(None): return "nil" - elif arg_type == IntType or arg_type == LongType: + elif arg_type is int: return "int" - elif arg_type == bool: + elif arg_type is bool: return "boolean" - elif arg_type == FloatType: + elif arg_type is float: return "double" - elif arg_type in StringTypes: + elif arg_type is str: return "string" - elif arg_type == ListType or arg_type == TupleType: + elif arg_type in (list, tuple): return "array" - elif arg_type == DictType: + elif arg_type is dict: return "struct" elif arg_type == Mixed: # Not really an XML-RPC type but return "mixed" for diff --git a/PLC/Peers.py b/PLC/Peers.py index 5b24ca2..c24f925 100644 --- a/PLC/Peers.py +++ b/PLC/Peers.py @@ -3,7 +3,6 @@ # import re -from types import StringTypes import traceback from urllib.parse import urlparse @@ -291,7 +290,7 @@ class Peers (Table): if isinstance(peer_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in peer_filter if isinstance(x, int)] - strs = [x for x in peer_filter if isinstance(x, StringTypes)] + strs = [x for x in peer_filter if isinstance(x, str)] peer_filter = Filter(Peer.fields, {'peer_id': ints, 'peername': strs}) sql += " AND (%s) %s" % peer_filter.sql(api, "OR") elif isinstance(peer_filter, dict): @@ -300,7 +299,7 @@ class Peers (Table): elif isinstance(peer_filter, int): peer_filter = Filter(Peer.fields, {'peer_id': peer_filter}) sql += " AND (%s) %s" % peer_filter.sql(api, "AND") - elif isinstance(peer_filter, StringTypes): + elif isinstance(peer_filter, str): peer_filter = Filter(Peer.fields, {'peername': peer_filter}) sql += " AND (%s) %s" % peer_filter.sql(api, "AND") else: diff --git a/PLC/Persons.py b/PLC/Persons.py index 30bdcfc..dc971b3 100644 --- a/PLC/Persons.py +++ b/PLC/Persons.py @@ -5,7 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes try: from hashlib import md5 except ImportError: @@ -388,14 +387,14 @@ class Persons(Table): if isinstance(person_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in person_filter if isinstance(x, int)] - strs = [x for x in person_filter if isinstance(x, StringTypes)] + strs = [x for x in person_filter if isinstance(x, str)] person_filter = Filter(Person.fields, {'person_id': ints, 'email': strs}) sql += " AND (%s) %s" % person_filter.sql(api, "OR") elif isinstance(person_filter, dict): allowed_fields=dict(list(Person.fields.items())+list(Person.tags.items())) person_filter = Filter(allowed_fields, person_filter) sql += " AND (%s) %s" % person_filter.sql(api, "AND") - elif isinstance (person_filter, StringTypes): + elif isinstance (person_filter, str): person_filter = Filter(Person.fields, {'email':person_filter}) sql += " AND (%s) %s" % person_filter.sql(api, "AND") elif isinstance (person_filter, int): diff --git a/PLC/PostgreSQL.py b/PLC/PostgreSQL.py index 27a8ab4..ae6c55a 100644 --- a/PLC/PostgreSQL.py +++ b/PLC/PostgreSQL.py @@ -1,5 +1,5 @@ # -# PostgreSQL database interface. +# PostgreSQL database interface. # Sort of like DBI(3) (Database independent interface for Perl). # # Mark Huang @@ -13,7 +13,6 @@ psycopg2.extensions.register_type(psycopg2.extensions.UNICODE) psycopg2.extensions.register_type(psycopg2._psycopg.UNICODEARRAY) import types -from types import StringTypes, NoneType import traceback import subprocess import re @@ -65,7 +64,7 @@ class PostgreSQL: x = str(x) elif isinstance(x, str): x = x.encode( 'utf-8' ) - + if isinstance(x, bytes): x = "'%s'" % str(x).replace("\\", "\\\\").replace("'", "''") elif isinstance(x, (int, float)): @@ -106,14 +105,14 @@ class PostgreSQL: @classmethod def param(self, name, value): # None is converted to the unquoted string NULL - if isinstance(value, NoneType): + if isinstance(value, type(None)): conversion = "s" # True and False are also converted to unquoted strings elif isinstance(value, bool): conversion = "s" elif isinstance(value, float): conversion = "f" - elif not isinstance(value, StringTypes): + elif not isinstance(value, str): conversion = "d" else: conversion = "s" diff --git a/PLC/Roles.py b/PLC/Roles.py index 283b386..415365b 100644 --- a/PLC/Roles.py +++ b/PLC/Roles.py @@ -5,7 +5,6 @@ # Copyright (C) 2006 The Trustees of Princeton University # -from types import StringTypes from PLC.Faults import * from PLC.Parameter import Parameter from PLC.Filter import Filter @@ -60,7 +59,7 @@ class Roles(Table): if isinstance(role_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in role_filter if isinstance(x, int)] - strs = [x for x in role_filter if isinstance(x, StringTypes)] + strs = [x for x in role_filter if isinstance(x, str)] role_filter = Filter(Role.fields, {'role_id': ints, 'name': strs}) sql += " AND (%s) %s" % role_filter.sql(api, "OR") elif isinstance(role_filter, dict): @@ -69,7 +68,7 @@ class Roles(Table): elif isinstance(role_filter, int): role_filter = Filter(Role.fields, {'role_id': role_filter}) sql += " AND (%s) %s" % role_filter.sql(api, "AND") - elif isinstance(role_filter, StringTypes): + elif isinstance(role_filter, str): role_filter = Filter(Role.fields, {'name': role_filter}) sql += " AND (%s) %s" % role_filter.sql(api, "AND") else: diff --git a/PLC/Sessions.py b/PLC/Sessions.py index 24ed8ad..511ed93 100644 --- a/PLC/Sessions.py +++ b/PLC/Sessions.py @@ -1,4 +1,3 @@ -from types import StringTypes import random import base64 import time @@ -74,7 +73,7 @@ class Sessions(Table): if isinstance(session_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in session_filter if isinstance(x, int)] - strs = [x for x in session_filter if isinstance(x, StringTypes)] + strs = [x for x in session_filter if isinstance(x, str)] session_filter = Filter(Session.fields, {'person_id': ints, 'session_id': strs}) sql += " AND (%s) %s" % session_filter.sql(api, "OR") elif isinstance(session_filter, dict): @@ -83,7 +82,7 @@ class Sessions(Table): elif isinstance(session_filter, int): session_filter = Filter(Session.fields, {'person_id': session_filter}) sql += " AND (%s) %s" % session_filter.sql(api, "AND") - elif isinstance(session_filter, StringTypes): + elif isinstance(session_filter, str): session_filter = Filter(Session.fields, {'session_id': session_filter}) sql += " AND (%s) %s" % session_filter.sql(api, "AND") else: diff --git a/PLC/Sites.py b/PLC/Sites.py index 213cd9a..9d565c4 100644 --- a/PLC/Sites.py +++ b/PLC/Sites.py @@ -1,4 +1,3 @@ -from types import StringTypes import string from PLC.Faults import * @@ -254,14 +253,14 @@ class Sites(Table): if isinstance(site_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in site_filter if isinstance(x, int)] - strs = [x for x in site_filter if isinstance(x, StringTypes)] + strs = [x for x in site_filter if isinstance(x, str)] site_filter = Filter(Site.fields, {'site_id': ints, 'login_base': strs}) sql += " AND (%s) %s" % site_filter.sql(api, "OR") elif isinstance(site_filter, dict): allowed_fields=dict(list(Site.fields.items())+list(Site.tags.items())) site_filter = Filter(allowed_fields, site_filter) sql += " AND (%s) %s" % site_filter.sql(api, "AND") - elif isinstance (site_filter, StringTypes): + elif isinstance (site_filter, str): site_filter = Filter(Site.fields, {'login_base':site_filter}) sql += " AND (%s) %s" % site_filter.sql(api, "AND") elif isinstance (site_filter, int): diff --git a/PLC/Slices.py b/PLC/Slices.py index 606273f..076d638 100644 --- a/PLC/Slices.py +++ b/PLC/Slices.py @@ -1,4 +1,3 @@ -from types import StringTypes import time import re @@ -277,14 +276,14 @@ class Slices(Table): if isinstance(slice_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in slice_filter if isinstance(x, int)] - strs = [x for x in slice_filter if isinstance(x, StringTypes)] + strs = [x for x in slice_filter if isinstance(x, str)] slice_filter = Filter(Slice.fields, {'slice_id': ints, 'name': strs}) sql += " AND (%s) %s" % slice_filter.sql(api, "OR") elif isinstance(slice_filter, dict): allowed_fields=dict(list(Slice.fields.items())+list(Slice.tags.items())) slice_filter = Filter(allowed_fields, slice_filter) sql += " AND (%s) %s" % slice_filter.sql(api, "AND") - elif isinstance (slice_filter, StringTypes): + elif isinstance (slice_filter, str): slice_filter = Filter(Slice.fields, {'name':slice_filter}) sql += " AND (%s) %s" % slice_filter.sql(api, "AND") elif isinstance (slice_filter, int): diff --git a/PLC/Table.py b/PLC/Table.py index 9d7d03c..a98ef18 100644 --- a/PLC/Table.py +++ b/PLC/Table.py @@ -1,4 +1,3 @@ -from types import StringTypes, IntType, LongType import time import calendar @@ -75,7 +74,7 @@ class Row(dict): if isinstance(items, (list, tuple, set)): ints = [x for x in items if isinstance(x, int)] - strs = [x for x in items if isinstance(x, StringTypes)] + strs = [x for x in items if isinstance(x, str)] dicts = [x for x in items if isinstance(x, dict)] return (ints, strs, dicts) else: @@ -339,8 +338,8 @@ class Row(dict): insert is True: # If primary key id is a serial int and it isnt included, get next id - if self.fields[self.primary_key].type in (IntType, LongType) and \ - self.primary_key not in self: + if (self.fields[self.primary_key].type is int + and self.primary_key not in self): pk_id = self.api.db.next_id(self.table_name, self.primary_key) self[self.primary_key] = pk_id db_fields[self.primary_key] = pk_id @@ -356,7 +355,7 @@ class Row(dict): .format(self.table_name, ", ".join(columns), self.primary_key, - self.api.db.param(self.primary_key, self[self.primary_key])) + self.api.db.param(self.primary_key, self[self.primary_key])) self.api.db.do(sql, db_fields) diff --git a/PLC/TagTypes.py b/PLC/TagTypes.py index 5fd924b..e477cec 100644 --- a/PLC/TagTypes.py +++ b/PLC/TagTypes.py @@ -1,8 +1,6 @@ # # Thierry Parmentelat - INRIA # -from types import StringTypes - from PLC.Faults import * from PLC.Parameter import Parameter from PLC.Filter import Filter @@ -61,7 +59,7 @@ class TagTypes(Table): if isinstance(tag_type_filter, (list, tuple, set)): # Separate the list into integers and strings ints = [x for x in tag_type_filter if isinstance(x, int)] - strs = [x for x in tag_type_filter if isinstance(x, StringTypes)] + strs = [x for x in tag_type_filter if isinstance(x, str)] tag_type_filter = Filter(TagType.fields, {'tag_type_id': ints, 'tagname': strs}) sql += " AND (%s) %s" % tag_type_filter.sql(api, "OR") elif isinstance(tag_type_filter, dict): @@ -70,7 +68,7 @@ class TagTypes(Table): elif isinstance(tag_type_filter, int): tag_type_filter = Filter(TagType.fields, {'tag_type_id':tag_type_filter}) sql += " AND (%s) %s" % tag_type_filter.sql(api, "AND") - elif isinstance(tag_type_filter, StringTypes): + elif isinstance(tag_type_filter, str): tag_type_filter = Filter(TagType.fields, {'tagname':tag_type_filter}) sql += " AND (%s) %s" % tag_type_filter.sql(api, "AND") else: diff --git a/PLC/Timestamp.py b/PLC/Timestamp.py index 149c6e5..faad925 100644 --- a/PLC/Timestamp.py +++ b/PLC/Timestamp.py @@ -5,7 +5,6 @@ # natively marshalled over xmlrpc # -from types import StringTypes import time, calendar import datetime @@ -59,12 +58,13 @@ class Timestamp: Returns a GMT timestamp string suitable to feed SQL. """ - if not timezone: output_format = Timestamp.sql_format - else: output_format = Timestamp.sql_format_utc + output_format = (Timestamp.sql_format_utc if timezone + else Timestamp.sql_format) - if Timestamp.debug: print('sql_validate, in:',input, end=' ') - if isinstance(input, StringTypes): - sql='' + if Timestamp.debug: + print('sql_validate, in:', input, end=' ') + if isinstance(input, str): + sql = '' # calendar.timegm() is the inverse of time.gmtime() for time_format in Timestamp.input_formats: try: @@ -72,11 +72,12 @@ class Timestamp: sql = time.strftime(output_format, time.gmtime(timestamp)) break # wrong format: ignore - except ValueError: pass + except ValueError: + pass # could not parse it if not sql: raise PLCInvalidArgument("Cannot parse timestamp %r - not in any of %r formats"%(input,Timestamp.input_formats)) - elif isinstance (input,(int,float)): + elif isinstance(input, (int, float)): try: timestamp = int(input) sql = time.strftime(output_format, time.gmtime(timestamp)) @@ -98,7 +99,7 @@ class Timestamp: @staticmethod - def cast_long (input): + def cast_long(input): """ Translates input timestamp as a unix timestamp. @@ -106,20 +107,24 @@ class Timestamp: 00:00:00 GMT), a string (in one of the supported input formats above). """ - if Timestamp.debug: print('cast_long, in:',input, end=' ') - if isinstance(input, StringTypes): - timestamp=0 + if Timestamp.debug: + print('cast_long, in:', input, end=' ') + if isinstance(input, str): + timestamp = 0 for time_format in Timestamp.input_formats: try: - result=calendar.timegm(time.strptime(input, time_format)) - if Timestamp.debug: print('out:',result) + result = calendar.timegm(time.strptime(input, time_format)) + if Timestamp.debug: + print('out:', result) return result # wrong format: ignore - except ValueError: pass - raise PLCInvalidArgument("Cannot parse timestamp %r - not in any of %r formats"%(input,Timestamp.input_formats)) - elif isinstance (input,(int,float)): - result=int(input) - if Timestamp.debug: print('out:',result) + except ValueError: + pass + raise PLCInvalidArgument("Cannot parse timestamp %r - not in any of %r formats"%(input, Timestamp.input_formats)) + elif isinstance(input, (int, float)): + result = int(input) + if Timestamp.debug: + print('out:',result) return result else: raise PLCInvalidArgument("Timestamp %r - unsupported type %r"%(input,type(input))) @@ -136,11 +141,13 @@ class Duration: @staticmethod def to_string(duration): result=[] - left=duration - (days,left) = divmod(left,Duration.DAY) - if days: result.append("%d d)"%td.days) - (hours,left) = divmod (left,Duration.HOUR) - if hours: result.append("%d h"%hours) + left = duration + (days, left) = divmod(left, Duration.DAY) + if days: + result.append("%d d)"%td.days) + (hours, left) = divmod (left, Duration.HOUR) + if hours: + result.append("%d h"%hours) (minutes, seconds) = divmod (left, Duration.MINUTE) if minutes: result.append("%d m"%minutes) if seconds: result.append("%d s"%seconds) @@ -151,6 +158,6 @@ class Duration: def validate (duration): # support seconds only for now, works for int/long/str try: - return int (duration) + return int(duration) except: raise PLCInvalidArgument("Could not parse duration %r"%duration) -- 2.43.0