castle 7.0.0__py3-none-any.whl

castle/api_request.py

@@ -0,0 +1,18 @@
+from castle.core.send_request import CoreSendRequest
+from castle.core.process_response import CoreProcessResponse
+from castle.configuration import configuration
+from castle.errors import ConfigurationError
+
+
+class APIRequest(object):
+    def __init__(self, config=configuration):
+        self.req = CoreSendRequest({'Content-Type': 'application/json'})
+        self.config = config
+
+    def request(self, command):
+        if not self.config.isValid():
+            raise ConfigurationError
+        return self.req.build_query(command.method, command.path, command.data, self.config)
+
+    def call(self, command):
+        return CoreProcessResponse(self.request(command)).call()

castle/client.py

@@ -0,0 +1,155 @@
+from castle.api_request import APIRequest
+from castle.commands.filter import CommandsFilter
+from castle.commands.log import CommandsLog
+from castle.commands.risk import CommandsRisk
+from castle.commands.lists.create import CommandsListsCreate
+from castle.commands.lists.get_all import CommandsListsGetAll
+from castle.commands.lists.get import CommandsListsGet
+from castle.commands.lists.query import CommandsListsQuery
+from castle.commands.lists.update import CommandsListsUpdate
+from castle.commands.lists.delete import CommandsListsDelete
+from castle.commands.list_items.create import CommandsListItemsCreate
+from castle.commands.list_items.create_batch import CommandsListItemsCreateBatch
+from castle.commands.list_items.get import CommandsListItemsGet
+from castle.commands.list_items.query import CommandsListItemsQuery
+from castle.commands.list_items.count import CommandsListItemsCount
+from castle.commands.list_items.update import CommandsListItemsUpdate
+from castle.commands.list_items.archive import CommandsListItemsArchive
+from castle.commands.list_items.unarchive import CommandsListItemsUnarchive
+from castle.commands.privacy.request_data import CommandsPrivacyRequestData
+from castle.commands.privacy.delete_data import CommandsPrivacyDeleteData
+from castle.configuration import configuration
+from castle.context.prepare import ContextPrepare
+from castle.errors import InternalServerError, RequestError
+from castle.failover.prepare_response import FailoverPrepareResponse
+from castle.failover.strategy import FailoverStrategy
+
+
+class Client(object):
+    @classmethod
+    def from_request(cls, request, options=None):
+        if options is None:
+            options = {}
+
+        options = options.copy()
+        options['context'] = ContextPrepare.call(request, options)
+        return cls(options)
+
+    @staticmethod
+    def failover_response_or_raise(user_id, exception):
+        if configuration.failover_strategy == FailoverStrategy.THROW.value:
+            raise exception
+        return FailoverPrepareResponse(user_id, None, exception.__class__.__name__).call()
+
+    def __init__(self, options=None):
+        if options is None:
+            options = {}
+        self.do_not_track = options.get('do_not_track', False)
+        self.timestamp = options.get('timestamp')
+        self.context = options.get('context')
+        self.api = APIRequest()
+
+    def _add_timestamp_if_necessary(self, options):
+        if self.timestamp:
+            options.setdefault('timestamp', self.timestamp)
+
+    def filter(self, options):
+        if self.tracked():
+            self._add_timestamp_if_necessary(options)
+            command = CommandsFilter(self.context).call(options)
+            try:
+                response = self.api.call(command)
+                response.update(failover=False, failover_reason=None)
+                return response
+            except (RequestError, InternalServerError) as exception:
+                return Client.failover_response_or_raise(self._failover_user_id(options), exception)
+        else:
+            return FailoverPrepareResponse(
+                self._failover_user_id(options), 'allow', 'Castle set to do not track.'
+            ).call()
+
+    def log(self, options):
+        if not self.tracked():
+            return None
+        self._add_timestamp_if_necessary(options)
+
+        return self.api.call(CommandsLog(self.context).call(options))
+
+    def risk(self, options):
+        if self.tracked():
+            self._add_timestamp_if_necessary(options)
+            command = CommandsRisk(self.context).call(options)
+            try:
+                response = self.api.call(command)
+                response.update(failover=False, failover_reason=None)
+                return response
+            except (RequestError, InternalServerError) as exception:
+                return Client.failover_response_or_raise(self._failover_user_id(options), exception)
+        else:
+            return FailoverPrepareResponse(
+                self._failover_user_id(options), 'allow', 'Castle set to do not track.'
+            ).call()
+
+    def create_list(self, options):
+        return self.api.call(CommandsListsCreate.call(options))
+
+    def get_all_lists(self, options=None):
+        return self.api.call(CommandsListsGetAll.call(options))
+
+    def get_list(self, options):
+        return self.api.call(CommandsListsGet.call(options))
+
+    def query_lists(self, options):
+        return self.api.call(CommandsListsQuery.call(options))
+
+    def update_list(self, options):
+        return self.api.call(CommandsListsUpdate.call(options))
+
+    def delete_list(self, options):
+        return self.api.call(CommandsListsDelete.call(options))
+
+    def create_list_item(self, options):
+        return self.api.call(CommandsListItemsCreate.call(options))
+
+    def create_batch_list_items(self, options):
+        return self.api.call(CommandsListItemsCreateBatch.call(options))
+
+    def get_list_item(self, options):
+        return self.api.call(CommandsListItemsGet.call(options))
+
+    def query_list_items(self, options):
+        return self.api.call(CommandsListItemsQuery.call(options))
+
+    def count_list_items(self, options):
+        return self.api.call(CommandsListItemsCount.call(options))
+
+    def update_list_item(self, options):
+        return self.api.call(CommandsListItemsUpdate.call(options))
+
+    def archive_list_item(self, options):
+        return self.api.call(CommandsListItemsArchive.call(options))
+
+    def unarchive_list_item(self, options):
+        return self.api.call(CommandsListItemsUnarchive.call(options))
+
+    def request_user_data(self, options):
+        return self.api.call(CommandsPrivacyRequestData.call(options))
+
+    def delete_user_data(self, options):
+        return self.api.call(CommandsPrivacyDeleteData.call(options))
+
+    def disable_tracking(self):
+        self.do_not_track = True
+
+    def enable_tracking(self):
+        self.do_not_track = False
+
+    def tracked(self):
+        return not self.do_not_track
+
+    @staticmethod
+    def _failover_user_id(options):
+        # `user` is optional on /v1/filter and may be omitted on /v1/log; fall
+        # back to `matching_user_id` then None instead of crashing.
+        user = options.get('user') or {}
+        return user.get('id') or options.get('matching_user_id')

castle/client_id/extract.py

@@ -0,0 +1,7 @@
+class ClientIdExtract(object):
+    def __init__(self, headers, cookies=None):
+        self.headers = headers
+        self.cookies = cookies or dict()
+
+    def call(self):
+        return self.headers.get('X-Castle-Client-Id', self.cookies.get('__cid', ''))

castle/command.py

@@ -0,0 +1,3 @@
+from collections import namedtuple
+
+Command = namedtuple('Command', ['path', 'data', 'method'])

castle/commands/filter.py

@@ -0,0 +1,18 @@
+from castle.command import Command
+from castle.utils.timestamp import UtilsTimestamp as generate_timestamp
+from castle.context.merge import ContextMerge
+from castle.context.sanitize import ContextSanitize
+
+
+class CommandsFilter(object):
+    def __init__(self, context):
+        self.context = context
+
+    def call(self, options):
+        context = ContextMerge.call(self.context, options.get('context'))
+        context = ContextSanitize.call(context)
+        if context:
+            options.update({'context': context})
+        options.update({'sent_at': generate_timestamp.call()})
+
+        return Command(method='post', path='filter', data=options)

castle/commands/list_items/archive.py

@@ -0,0 +1,17 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsArchive(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id', 'list_item_id')
+
+        return Command(
+            method='delete',
+            path='lists/{list_id}/items/{list_item_id}/archive'.format(
+                list_id=options['list_id'], list_item_id=options['list_item_id']
+            ),
+            data=None,
+        )

castle/commands/list_items/count.py

@@ -0,0 +1,17 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsCount(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id')
+        for query_filter in options.get('filters') or []:
+            ValidatorsPresent.call(query_filter, 'field', 'op', 'value')
+
+        list_id = options.pop('list_id')
+
+        return Command(
+            method='post', path='lists/{list_id}/items/count'.format(list_id=list_id), data=options
+        )

castle/commands/list_items/create.py

@@ -0,0 +1,15 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsCreate(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id', 'author', 'primary_value')
+
+        list_id = options.pop('list_id')
+
+        return Command(
+            method='post', path='lists/{list_id}/items'.format(list_id=list_id), data=options
+        )

castle/commands/list_items/create_batch.py

@@ -0,0 +1,15 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsCreateBatch(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id', 'items')
+
+        list_id = options.pop('list_id')
+
+        return Command(
+            method='post', path='lists/{list_id}/items/batch'.format(list_id=list_id), data=options
+        )

castle/commands/list_items/get.py

@@ -0,0 +1,17 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsGet(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id', 'list_item_id')
+
+        return Command(
+            method='get',
+            path='lists/{list_id}/items/{list_item_id}'.format(
+                list_id=options['list_id'], list_item_id=options['list_item_id']
+            ),
+            data=None,
+        )

castle/commands/list_items/query.py

@@ -0,0 +1,19 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsQuery(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id')
+        for query_filter in options.get('filters') or []:
+            ValidatorsPresent.call(query_filter, 'field', 'op', 'value')
+        if options.get('sort'):
+            ValidatorsPresent.call(options['sort'], 'field', 'order')
+
+        list_id = options.pop('list_id')
+
+        return Command(
+            method='post', path='lists/{list_id}/items/query'.format(list_id=list_id), data=options
+        )

castle/commands/list_items/unarchive.py

@@ -0,0 +1,17 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsUnarchive(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id', 'list_item_id')
+
+        return Command(
+            method='put',
+            path='lists/{list_id}/items/{list_item_id}/unarchive'.format(
+                list_id=options['list_id'], list_item_id=options['list_item_id']
+            ),
+            data=None,
+        )

castle/commands/list_items/update.py

@@ -0,0 +1,20 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListItemsUpdate(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id', 'list_item_id', 'comment')
+
+        list_id = options.pop('list_id')
+        list_item_id = options.pop('list_item_id')
+
+        return Command(
+            method='put',
+            path='lists/{list_id}/items/{list_item_id}'.format(
+                list_id=list_id, list_item_id=list_item_id
+            ),
+            data=options,
+        )

castle/commands/lists/create.py

@@ -0,0 +1,11 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListsCreate(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'name', 'color', 'primary_field')
+
+        return Command(method='post', path='lists', data=options)

castle/commands/lists/delete.py

@@ -0,0 +1,13 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListsDelete(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id')
+
+        return Command(
+            method='delete', path='lists/{list_id}'.format(list_id=options['list_id']), data=None
+        )

castle/commands/lists/get.py

@@ -0,0 +1,13 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListsGet(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id')
+
+        return Command(
+            method='get', path='lists/{list_id}'.format(list_id=options['list_id']), data=None
+        )

castle/commands/lists/get_all.py

@@ -0,0 +1,7 @@
+from castle.command import Command
+
+
+class CommandsListsGetAll(object):
+    @staticmethod
+    def call(options=None):
+        return Command(method='get', path='lists', data=None)

castle/commands/lists/query.py

@@ -0,0 +1,14 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListsQuery(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        for query_filter in options.get('filters') or []:
+            ValidatorsPresent.call(query_filter, 'field', 'op', 'value')
+        if options.get('sort'):
+            ValidatorsPresent.call(options['sort'], 'field', 'order')
+
+        return Command(method='post', path='lists/query', data=options)

castle/commands/lists/update.py

@@ -0,0 +1,13 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsListsUpdate(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'list_id')
+
+        list_id = options.pop('list_id')
+
+        return Command(method='put', path='lists/{list_id}'.format(list_id=list_id), data=options)

castle/commands/log.py

@@ -0,0 +1,18 @@
+from castle.command import Command
+from castle.utils.timestamp import UtilsTimestamp as generate_timestamp
+from castle.context.merge import ContextMerge
+from castle.context.sanitize import ContextSanitize
+
+
+class CommandsLog(object):
+    def __init__(self, context):
+        self.context = context
+
+    def call(self, options):
+        context = ContextMerge.call(self.context, options.get('context'))
+        context = ContextSanitize.call(context)
+        if context:
+            options.update({'context': context})
+        options.update({'sent_at': generate_timestamp.call()})
+
+        return Command(method='post', path='log', data=options)

castle/commands/privacy/delete_data.py

@@ -0,0 +1,11 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsPrivacyDeleteData(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'identifier', 'identifier_type')
+
+        return Command(method='delete', path='privacy/users', data=options)

castle/commands/privacy/request_data.py

@@ -0,0 +1,11 @@
+from castle.command import Command
+from castle.validators.present import ValidatorsPresent
+
+
+class CommandsPrivacyRequestData(object):
+    @staticmethod
+    def call(options=None):
+        options = options or {}
+        ValidatorsPresent.call(options, 'identifier', 'identifier_type')
+
+        return Command(method='post', path='privacy/users', data=options)

castle/commands/risk.py

@@ -0,0 +1,18 @@
+from castle.command import Command
+from castle.utils.timestamp import UtilsTimestamp as generate_timestamp
+from castle.context.merge import ContextMerge
+from castle.context.sanitize import ContextSanitize
+
+
+class CommandsRisk(object):
+    def __init__(self, context):
+        self.context = context
+
+    def call(self, options):
+        context = ContextMerge.call(self.context, options.get('context'))
+        context = ContextSanitize.call(context)
+        if context:
+            options.update({'context': context})
+        options.update({'sent_at': generate_timestamp.call()})
+
+        return Command(method='post', path='risk', data=options)