"""

HOST = "localhost"

PORT = 27017

# Define order to retrieve options from ClientOptions for __repr__.

# No host/port; these are retrieved from TopologySettings.

_constructor_args = ('document_class', 'tz_aware', 'connect')

def __init__(

self,

host=None,

port=None,

document_class=dict,

tz_aware=None,

connect=None,

**kwargs):

"""Client for a MongoDB instance, a replica set, or a set of mongoses.

if host is None:

host = self.HOST

if isinstance(host, string_type):

host = [host]

if port is None:

port = self.PORT

if not isinstance(port, int):

raise TypeError("port must be an instance of int")

seeds = set()

username = None

password = None

dbase = None

opts = {}

for entity in host:

if "://" in entity:

res = uri_parser.parse_uri(

entity, port, validate=True, warn=True)

seeds.update(res["nodelist"])

username = res["username"] or username

password = res["password"] or password

dbase = res["database"] or dbase

opts = res["options"]

else:

seeds.update(uri_parser.split_hosts(entity, port))

if not seeds:

raise ConfigurationError("need to specify at least one host")

# _pool_class, _monitor_class, and _condition_class are for deep

# customization of PyMongo, e.g. Motor.

pool_class = kwargs.pop('_pool_class', None)

monitor_class = kwargs.pop('_monitor_class', None)

condition_class = kwargs.pop('_condition_class', None)

keyword_opts = kwargs

keyword_opts['document_class'] = document_class

if tz_aware is None:

tz_aware = opts.get('tz_aware', False)

if connect is None:

connect = opts.get('connect', True)

keyword_opts['tz_aware'] = tz_aware

keyword_opts['connect'] = connect

# Validate kwargs options.

keyword_opts = _CaseInsensitiveDictionary(

dict(common.validate(k, v) for k, v in keyword_opts.items()))

# Handle deprecated options in kwarg list.

keyword_opts = _handle_option_deprecations(keyword_opts)

# Change kwarg option names to those used internally.

keyword_opts = _normalize_options(keyword_opts)

# Augment URI options with kwarg options, overriding the former.

opts.update(keyword_opts)

# Username and password passed as kwargs override user info in URI.

username = opts.get("username", username)

password = opts.get("password", password)

if 'socketkeepalive' in opts:

warnings.warn(

"The socketKeepAlive option is deprecated. It now"

"defaults to true and disabling it is not recommended, see "

"https://docs.mongodb.com/manual/faq/diagnostics/"

"#does-tcp-keepalive-time-affect-mongodb-deployments",

DeprecationWarning, stacklevel=2)

self.__options = options = ClientOptions(

username, password, dbase, opts)

self.__default_database_name = dbase

self.__lock = threading.Lock()

self.__cursor_manager = None

self.__kill_cursors_queue = []

self._event_listeners = options.pool_options.event_listeners

# Cache of existing indexes used by ensure_index ops.

self.__index_cache = {}

self.__index_cache_lock = threading.Lock()

super(MongoClient, self).__init__(options.codec_options,

options.read_preference,

options.write_concern,

options.read_concern)

self.__all_credentials = {}

creds = options.credentials

if creds:

self._cache_credentials(creds.source, creds)

self._topology_settings = TopologySettings(

seeds=seeds,

replica_set_name=options.replica_set_name,

pool_class=pool_class,

pool_options=options.pool_options,

monitor_class=monitor_class,

condition_class=condition_class,

local_threshold_ms=options.local_threshold_ms,

server_selection_timeout=options.server_selection_timeout,

server_selector=options.server_selector,

heartbeat_frequency=options.heartbeat_frequency)

self._topology = Topology(self._topology_settings)

if connect:

self._topology.open()

def target():

client = self_ref()

if client is None:

return False # Stop the executor.

MongoClient._process_periodic_tasks(client)

return True

executor = periodic_executor.PeriodicExecutor(

interval=common.KILL_CURSOR_FREQUENCY,

min_interval=0.5,

target=target,

name="pymongo_kill_cursors_thread")

# We strongly reference the executor and it weakly references us via

# this closure. When the client is freed, stop the executor soon.

self_ref = weakref.ref(self, executor.close)

self._kill_cursors_executor = executor

executor.open()

def _cache_credentials(self, source, credentials, connect=False):

"""Save a set of authentication credentials.

# Don't let other threads affect this call's data.

all_credentials = self.__all_credentials.copy()

if source in all_credentials:

# Nothing to do if we already have these credentials.

if credentials == all_credentials[source]:

return

raise OperationFailure('Another user is already authenticated '

'to this database. You must logout first.')

if connect:

server = self._get_topology().select_server(

writable_preferred_server_selector)

# get_socket() logs out of the database if logged in with old

# credentials, and logs in with new ones.

with server.get_socket(all_credentials) as sock_info:

sock_info.authenticate(credentials)

# If several threads run _cache_credentials at once, last one wins.

self.__all_credentials[source] = credentials

def _purge_credentials(self, source):

"""Purge credentials from the authentication cache."""

self.__all_credentials.pop(source, None)

def _cached(self, dbname, coll, index):

"""Test if `index` is cached."""

cache = self.__index_cache

now = datetime.datetime.utcnow()

with self.__index_cache_lock:

return (dbname in cache and

coll in cache[dbname] and

index in cache[dbname][coll] and

now < cache[dbname][coll][index])

def _cache_index(self, dbname, collection, index, cache_for):

"""Add an index to the index cache for ensure_index operations."""

now = datetime.datetime.utcnow()

expire = datetime.timedelta(seconds=cache_for) + now

with self.__index_cache_lock:

if dbname not in self.__index_cache:

self.__index_cache[dbname] = {}

self.__index_cache[dbname][collection] = {}

self.__index_cache[dbname][collection][index] = expire

elif collection not in self.__index_cache[dbname]:

self.__index_cache[dbname][collection] = {}

self.__index_cache[dbname][collection][index] = expire

else:

self.__index_cache[dbname][collection][index] = expire

def _purge_index(self, database_name,

collection_name=None, index_name=None):

"""Purge an index from the index cache.

with self.__index_cache_lock:

if not database_name in self.__index_cache:

return

if collection_name is None:

del self.__index_cache[database_name]

return

if not collection_name in self.__index_cache[database_name]:

return

if index_name is None:

del self.__index_cache[database_name][collection_name]

return

if index_name in self.__index_cache[database_name][collection_name]:

del self.__index_cache[database_name][collection_name][index_name]

def _server_property(self, attr_name):

"""An attribute of the current server's description.

server = self._topology.select_server(

writable_server_selector)

return getattr(server.description, attr_name)

def watch(self, pipeline=None, full_document='default', resume_after=None,

max_await_time_ms=None, batch_size=None, collation=None,

start_at_operation_time=None, session=None):

"""Watch changes on this cluster.

return ClusterChangeStream(

self.admin, pipeline, full_document, resume_after, max_await_time_ms,

batch_size, collation, start_at_operation_time, session

)

@property

def event_listeners(self):

"""The event listeners registered for this client.

return self._event_listeners.event_listeners

@property

def address(self):

"""(host, port) of the current standalone, primary, or mongos, or None.

topology_type = self._topology._description.topology_type

if topology_type == TOPOLOGY_TYPE.Sharded:

raise InvalidOperation(

'Cannot use "address" property when load balancing among'

' mongoses, use "nodes" instead.')

if topology_type not in (TOPOLOGY_TYPE.ReplicaSetWithPrimary,

TOPOLOGY_TYPE.Single):

return None

return self._server_property('address')

@property

def primary(self):

"""The (host, port) of the current primary of the replica set.

return self._topology.get_primary()

@property

def secondaries(self):

"""The secondary members known to this client.

return self._topology.get_secondaries()

@property

def arbiters(self):

"""Arbiters in the replica set.

return self._topology.get_arbiters()

@property

def is_primary(self):

"""If this client is connected to a server that can accept writes.

return self._server_property('is_writable')

@property

def is_mongos(self):

"""If this client is connected to mongos. If the client is not

return self._server_property('server_type') == SERVER_TYPE.Mongos

@property

def max_pool_size(self):

"""The maximum allowable number of concurrent connections to each

return self.__options.pool_options.max_pool_size

@property

def min_pool_size(self):

"""The minimum required number of concurrent connections that the pool

return self.__options.pool_options.min_pool_size

@property

def max_idle_time_ms(self):

"""The maximum number of milliseconds that a connection can remain

seconds = self.__options.pool_options.max_idle_time_seconds

if seconds is None:

return None

return 1000 * seconds

@property

def nodes(self):

"""Set of all currently connected servers.

description = self._topology.description

return frozenset(s.address for s in description.known_servers)

@property

def max_bson_size(self):

"""The largest BSON object the connected server accepts in bytes.

return self._server_property('max_bson_size')

@property

def max_message_size(self):

"""The largest message the connected server accepts in bytes.

return self._server_property('max_message_size')

@property

def max_write_batch_size(self):

"""The maxWriteBatchSize reported by the server.