channel-app 0.0.131__py3-none-any.whl → 0.0.135__py3-none-any.whl

channel_app/channel_app/core/integration.py

@@ -1,74 +0,0 @@
-import asyncio
-from typing import Any
-
-from omnisdk.omnitron.endpoints import CatalogEndpoint, ChannelEndpoint
-from omnisdk.omnitron.models import Catalog, Channel
-
-
-class BaseIntegration(object):
-    """
-    To integrate with any system you must create a class which inherits from BaseIntegration.
-    This class was designed to work with `command design pattern` which basically defines
-    a task procedure interface. All defined commands override some of the default base
-    methods according to their requirements.
-    """
-    actions = {}
-
-    def get_action(self, key: str):
-        return self.actions[key]
-
-    def do_action(self, key: str, **kwargs) -> Any:
-        """
-        Runs the command given with the key and supplies the additional parameters to the command.
-
-        :param key: Command key
-        :param kwargs: Any additional parameters can be specified, for example `objects` must be
-            supplied if you want to provide input to the action.
-
-        :return: Result of the command
-
-        """
-        action_class = self.get_action(key)
-        action_object = action_class(integration=self, **kwargs)
-        return action_object.run()
-
-    def do_action_async_run(self, key: str, **kwargs) -> Any:
-        """
-        Runs the command given with the key asynchronously and supplies the additional parameters
-        to the command.
-
-        :param key: Command key
-        :param kwargs: Any additional parameters can be specified, for example `objects` must be
-            supplied if you want to provide input to the action.
-
-        :return: Result of the command
-
-        """
-
-        action_class = self.get_action(key)
-        action_object = action_class(integration=self, **kwargs)
-        return asyncio.run(action_object.run_async())
-
-    @property
-    def catalog(self) -> Catalog:
-        """
-        Retrieves the catalog object using the `catalog_id` stored in the `self`.
-
-        Side effect: It stores the result in the `self.catalog_object`, if catalog is updated
-        on the currently running task you must delete self.catalog_object and re-call this method
-        """
-        if not getattr(self, 'catalog_object', None):
-            self.catalog_object = CatalogEndpoint().retrieve(id=self.catalog_id)
-        return self.catalog_object
-
-    @property
-    def channel(self) -> Channel:
-        """
-        Retrieves the channel object using the `channel_id` stored in the `self`.
-
-        Side effect: It stores the result in the `self.channel_object`, if channel is updated
-        on the currently running task you must delete self.channel_object and re-call this method
-        """
-        if not getattr(self, 'channel_object', None):
-            self.channel_object = ChannelEndpoint().retrieve(id=self.channel_id)
-        return self.channel_object

channel_app/channel_app/core/products.py

@@ -1,64 +0,0 @@
-import functools
-from collections import defaultdict
-
-
-class ProductCommonMixin(object):
-    def group_by_product_id(self, products):
-        """
-       # products were grouped by color which was grouped by color
-       :param products: [product1,product2]
-       :return: Dict {"base_code-color":[product1,product2]}
-       """
-        group = defaultdict(list)
-        for p in products:
-            key = self.get_product_id(p)
-            group[key].append(p)
-        return group
-
-    def get_product_id(self, obj):
-        """
-        # Your internal product id to reference for
-        # this product.
-        :param obj:
-        :return: String (required)
-        """
-        product_id = getattr(obj, "mapped_attributes", {}).get(
-            "mapped_attributes", {}).get("product_id", None)
-        if product_id:
-            return product_id
-        return self.get_color(obj)
-
-    @staticmethod
-    def get_reduce_data(code, value):
-        try:
-            data = functools.reduce(
-                lambda d, key: d.get(key, None) if isinstance(d,
-                                                              dict) else None,
-                code.split("__"), value)
-            return data
-        except TypeError:
-            return None
-
-    def get_color(self, obj):
-        """
-        # Valid color provided by namshi
-        :param obj:
-        :return:String (required,namshi_lookup)
-        """
-        color = getattr(obj, "mapped_attributes", {}).get(
-            "mapped_attributes", {}).get("color", obj.listing_code)
-        color = color and obj.attributes["renk"]
-        return color
-
-    def get_barcode(self, obj):
-        """
-        # The barcode uniquely identifying a
-        # certain product line across
-        remote_id_attribute = ["attributes","barcode"], ["sku"]
-        :param obj:
-        :return: String (required)
-        """
-        remote_id_attribute = self.integration.channel.conf.get("remote_id_attribute")
-        if remote_id_attribute:
-            return self.get_reduce_data(remote_id_attribute, obj.__dict__)
-        return obj.sku

channel_app/channel_app/core/settings.py

@@ -1,28 +0,0 @@
-import importlib
-import os
-
-env_variables = os.environ
-
-OMNITRON_CHANNEL_ID = os.getenv("OMNITRON_CHANNEL_ID")
-OMNITRON_USER = os.getenv("OMNITRON_USERNAME")
-OMNITRON_PASSWORD = os.getenv("OMNITRON_PASSWORD")
-MAIN_APP_URL = os.getenv("MAIN_APP_URL")
-OMNITRON_URL = f"https://{MAIN_APP_URL}/"
-OMNITRON_CATALOG_ID = os.getenv("OMNITRON_CATALOG_ID")
-CACHE_DATABASE_INDEX = os.getenv("CACHE_DATABASE_INDEX")
-CACHE_HOST = os.getenv("CACHE_HOST")
-CACHE_PORT = os.getenv("CACHE_PORT")
-BROKER_HOST = os.getenv("BROKER_HOST")
-BROKER_PORT = os.getenv("BROKER_PORT")
-BROKER_DATABASE_INDEX = os.getenv("BROKER_DATABASE_INDEX")
-SENTRY_DSN = os.getenv("SENTRY_DSN")
-DEFAULT_CONNECTION_POOL_COUNT = os.getenv("DEFAULT_CONNECTION_POOL_COUNT") or 10
-DEFAULT_CONNECTION_POOL_MAX_SIZE = os.getenv("DEFAULT_CONNECTION_POOL_COUNT") or 10
-DEFAULT_CONNECTION_POOL_RETRY = os.getenv("DEFAULT_CONNECTION_POOL_RETRY") or 0
-REQUEST_LOG = os.getenv("REQUEST_LOG") or False
-
-omnitron_module = importlib.import_module(os.environ.get("OMNITRON_MODULE"))
-OmnitronIntegration = omnitron_module.OmnitronIntegration
-
-channel_module = importlib.import_module(os.environ.get("CHANNEL_MODULE"))
-ChannelIntegration = channel_module.ChannelIntegration

channel_app/channel_app/core/utilities.py

@@ -1,99 +0,0 @@
-import logging
-from datetime import datetime
-
-from celery import current_app as app
-
-from channel_app.core.clients import RedisClient
-
-logger = logging.getLogger(__name__)
-
-
-class LockTask(app.Task):
-    """this abstract class ensures the same tasks run only once at a time"""
-    abstract = True
-
-    def __init__(self, *args, **kwargs):
-        from channel_app.core import settings
-        self.TTL = getattr(settings, 'DEFAULT_TASK_LOCK_TTL', 60 * 15)
-        self.redis = RedisClient()
-        super(LockTask, self).__init__(*args, **kwargs)
-
-    def generate_lock_cache_key(self, *args, **kwargs):
-        args_key = [str(arg) for arg in args]
-        kwargs_key = ['{}_{}'.format(k, str(v)) for k, v in
-                      sorted(kwargs.items())]
-        return '_'.join([self.name] + args_key + kwargs_key)
-
-    def __call__(self, *args, **kwargs):
-        """check task"""
-        lock_cache_key = (self.request.headers or {}).pop('cache_key', None)
-        if not lock_cache_key:
-            lock_cache_key = self.generate_lock_cache_key(*args, **kwargs)
-
-        if self.lock_acquired(lock_cache_key):
-            try:
-                return self.run(*args, **kwargs)
-            finally:
-                pass
-        else:
-            return f'Task {self.name} is already running..'
-
-    def lock_acquired(self, lock_cache_key):
-        lock_acquired = True
-        app_inspect = self.app.control.inspect()
-        active_task = app_inspect.active(safe=True)
-        if not active_task:
-            return lock_acquired
-        for worker_name, task_list in active_task.items():
-            for task in task_list:
-                if (task.get("name", None) == lock_cache_key) and (
-                        self.request.id != task['id']):
-                    lock_acquired = False
-                    break
-        return lock_acquired
-
-
-def split_list(lst, n):
-    """
-    Split a list to chunks of n
-    :param lst:
-    :param n:
-    :return iterator to get chunks
-    """
-    for i in range(0, len(lst), n):
-        yield lst[i:i + n]
-
-
-def request_log():
-    import logging
-    try:
-        import http.client as http_client
-    except ImportError:
-        import httplib as http_client
-
-    http_client.HTTPConnection.debuglevel = 1
-    logging.basicConfig()
-    logging.getLogger().setLevel(logging.DEBUG)
-    requests_log = logging.getLogger("requests.packages.urllib3")
-    requests_log.setLevel(logging.DEBUG)
-    requests_log.propagate = True
-
-
-def is_updated(current, new):
-    no_default = "NO_DEFAULT"
-    for key, new_value in new.items():
-        old_value = getattr(current, key, no_default)
-        if old_value != no_default and old_value != new_value:
-            return True
-    return False
-
-
-def lowercase_keys(obj):
-    if isinstance(obj, dict):
-        obj = {key.lower(): value for key, value in obj.items()}
-        for key, value in obj.items():
-            if isinstance(value, list):
-                for idx, item in enumerate(value):
-                    value[idx] = lowercase_keys(value[idx])
-            obj[key] = value
-    return obj

channel_app/channel_app/omnitron/batch_request.py

@@ -1,82 +0,0 @@
-from omnisdk.omnitron.endpoints import ChannelBatchRequestEndpoint
-from omnisdk.omnitron.models import BatchRequest
-
-from channel_app.omnitron.constants import BatchRequestStatus
-
-
-class ClientBatchRequest(object):
-    """
-    Batch requests work as a state machine. They are used to track state of a flow that must
-    be running across multiple systems. It starts at initialized state.
-    """
-    def __init__(self, channel_id):
-        self.channel_id = channel_id
-        self.endpoint = ChannelBatchRequestEndpoint()
-
-    def create(self) -> BatchRequest:
-        batch_request = BatchRequest(channel=self.channel_id)
-        return self.endpoint(channel_id=self.channel_id).create(item=batch_request)
-
-    def to_commit(self, batch_request: BatchRequest) -> BatchRequest:
-        """
-        Once objects are fetched by Channel app, state is updated to commit and object
-        integration are marked(if sent) on Omnitron side.
-        :param batch_request:
-        :return:
-        """
-        br = BatchRequest(channel=self.channel_id)
-        br.objects = batch_request.objects
-        br.status = BatchRequestStatus.commit.value
-        br.content_type = batch_request.content_type
-        return self.endpoint(channel_id=self.channel_id).update(id=batch_request.pk, item=br)
-
-    def to_sent_to_remote(self, batch_request: BatchRequest) -> BatchRequest:
-        """
-        If objects are sent to channel, state must be updated to sent_to_remote
-        and channel batch id is stored if it sent one.
-        :param batch_request:
-        :return:
-        """
-        br = BatchRequest(channel=self.channel_id)
-        br.remote_batch_id = batch_request.remote_batch_id
-        br.status = BatchRequestStatus.sent_to_remote.value
-        return self.endpoint(channel_id=self.channel_id).update(
-            id=batch_request.pk, item=br)
-
-    def to_ongoing(self, batch_request: BatchRequest) -> BatchRequest:
-        """
-        If channel has not finished the batch yet, once we query for it after an interval, we
-        update the state to ongoing.
-        :param batch_request:
-        :return:
-        """
-        br = BatchRequest(channel=self.channel_id)
-        br.status = BatchRequestStatus.ongoing.value
-        return self.endpoint(channel_id=self.channel_id).update(
-            id=batch_request.pk, item=br)
-
-    def to_fail(self, batch_request: BatchRequest) -> BatchRequest:
-        """
-        If channel fails completing the batch, batch request is finalized with fail state.
-        :param batch_request:
-        :return:
-        """
-        br = BatchRequest(channel=self.channel_id)
-        br.objects = batch_request.objects
-        br.status = BatchRequestStatus.fail.value
-        return self.endpoint(channel_id=self.channel_id).update(
-            id=batch_request.pk, item=br)
-
-    def to_done(self, batch_request: BatchRequest) -> BatchRequest:
-        """
-        If all objects are processed disregarding the fact that they succeeded or failed,
-        batch request is finalized with done.
-        :param batch_request:
-        :return:
-        """
-        br = BatchRequest(channel=self.channel_id)
-        br.objects = batch_request.objects
-        br.status = BatchRequestStatus.done.value
-        return self.endpoint(channel_id=self.channel_id).update(
-            id=batch_request.pk, item=br)
-

channel_app/channel_app/omnitron/commands/batch_requests.py

@@ -1,281 +0,0 @@
-import functools
-from collections import defaultdict
-
-from omnisdk.omnitron.endpoints import (ChannelBatchRequestEndpoint,
-                                        ChannelIntegrationActionEndpoint,
-                                        ChannelProductEndpoint,
-                                        ChannelProductPriceEndpoint,
-                                        ChannelProductStockEndpoint,
-                                        ChannelProductImageEndpoint)
-
-from channel_app.core.commands import OmnitronCommandInterface
-from channel_app.core.utilities import split_list
-from channel_app.omnitron.constants import FailedReasonType, ResponseStatus
-
-
-class GetBatchRequests(OmnitronCommandInterface):
-    """
-    Fetches BatchRequest entries. For example, we can fetch
-    BatchRequests with status 'sent_to_remote'
-
-    There is no state transition in this command.
-
-     :return: List[BatchRequest] as output of do_action
-    """
-    endpoint = ChannelBatchRequestEndpoint
-
-    def get_data(self):
-        """
-        
-        [{
-            "pk": 22,
-            "channel": 6,
-            "local_batch_id": "89bb31b0-6700-4a9d-8bae-308ac938649c",
-            "remote_batch_id": "028b8e66-2a4c-45b5-912f-9ab90036c78a",
-            "content_type": "product",
-            "status": "sent_to_remote"
-        },]
-        :return:
-        """
-        params = getattr(self, "param_{}".format("params"), None)
-        if not params:
-            return []
-
-        batch_requests = self.endpoint(
-            channel_id=self.integration.channel_id
-        ).list(params=params)
-        return batch_requests
-
-
-class BatchRequestUpdate(OmnitronCommandInterface):
-    endpoint = ChannelBatchRequestEndpoint
-
-    def send(self, validated_data) -> object:
-        result = self.endpoint(channel_id=self.integration.channel_id).update(
-            id=validated_data.pk, item=validated_data)
-        return result
-
-
-class ProcessBatchRequests(object):
-    def get_integration_actions_to_processing(self):
-        integration_action_endpoint = ChannelIntegrationActionEndpoint(
-            channel_id=self.integration.channel_id)
-        batch_integration_action = integration_action_endpoint.list(
-            params={
-                "local_batch_id": self.integration.batch_request.local_batch_id,
-                "channel_id": self.integration.channel_id,
-                "status": "processing",
-                "limit": self.CHUNK_SIZE,
-                "sort": "id"})
-        for batch in integration_action_endpoint.iterator:
-            if not batch:
-                break
-            batch_integration_action.extend(batch)
-        return batch_integration_action
-
-    def group_model_items_by_content_type(self, items_by_content):
-        """
-        :return {
-            "product": {pk1: product1, pk2: product2, pk3: product3},
-            "productstock": {pk1: productstock1, pk2: productstock1, pk3: productstock3},
-            "productprice": {pk1: productprice1, pk2: productprice2, pk3: productprice3},
-            ...
-        }
-        """
-        batch_items = {}
-        for model, model_pks in items_by_content.items():
-            if model == "product":
-                group_items = self.get_products(model_pks)
-            elif model == "productstock":
-                group_items = self.get_stocks(model_pks)
-            elif model == "productprice":
-                group_items = self.get_prices(model_pks)
-            elif model == "productimage":
-                group_items = self.get_images(model_pks)
-            else:
-                raise NotImplementedError
-            batch_items[model] = group_items
-        return batch_items
-
-    def group_integration_actions_by_content_type(self,
-                                                  batch_integration_actions):
-        """
-
-        :param batch_integration_actions:
-        :return: {
-            "product": [product_pk1, product_pk2, product_pk3, ...],
-            "productprice": [productprice_pk1, productprice_pk2, ...]
-        }
-        """
-        items_by_content = {}
-        for integration_action in batch_integration_actions:
-            content_type = integration_action.content_type["model"]
-            if content_type not in items_by_content:
-                items_by_content[content_type] = []
-            items_by_content[content_type].append(
-                str(integration_action.object_id))
-        return items_by_content
-
-    def get_products(self, id_list) -> dict:
-        end_point = ChannelProductEndpoint(
-            channel_id=self.integration.channel_id)
-        products = []
-        for chunk_id_list in split_list(id_list, self.CHUNK_SIZE):
-            products_batch = end_point.list(
-                params={"pk__in": ",".join(id_list),
-                        "limit": len(chunk_id_list)})
-            products.extend(products_batch)
-
-        return {s.pk: s for s in products}
-
-    def get_prices(self, id_list: list) -> dict:
-        """
-        param id_list: productprice pk list
-        :return: dict of prices with key product id
-        {
-            1111:{"pk":2222, "stock":5, ...},
-        }
-        """
-        if not id_list:
-            return {}
-
-        endpoint = ChannelProductPriceEndpoint(
-            channel_id=self.integration.channel_id)
-        prices = []
-        for chunk in split_list(id_list, self.CHUNK_SIZE):
-            # TODO should we check the size of chunk (len(chunk) == len(stock_batch))
-            #  to validate something is missing on omnitron side?
-            price_batch = endpoint.list(params={"pk__in": ",".join(chunk),
-                                                "limit": len(chunk)})
-            prices.extend(price_batch)
-        return {p.product: p for p in prices if str(p.pk) in id_list}
-
-    def get_stocks(self, id_list: list) -> dict:
-        """
-        :param id_list:
-        :return: dict of stocks with key product id
-        {
-            1111:{"pk":3333, price:19.99, ...},
-        }
-        """
-        if not id_list:
-            return {}
-        endpoint = ChannelProductStockEndpoint(
-            channel_id=self.integration.channel_id)
-        stocks = []
-        for chunk in split_list(id_list, self.CHUNK_SIZE):
-            # TODO should we check the size of chunk (len(chunk) == len(stock_batch))
-            #  to validate something is missing on omnitron side?
-            stock_batch = endpoint.list(params={"pk__in": ",".join(chunk),
-                                                "limit": len(chunk)})
-            stocks.extend(stock_batch)
-            if not stock_batch:
-                break
-        return {s.product: s for s in stocks if str(s.pk) in id_list}
-
-    def get_images(self, id_list):
-        if not id_list:
-            return {}
-        endpoint = ChannelProductImageEndpoint(
-            channel_id=self.integration.channel_id)
-        images = []
-        for chunk in split_list(id_list, self.CHUNK_SIZE):
-            image_batch = endpoint.list(params={"id__in": ",".join(chunk)})
-            images.extend(image_batch)
-            if not image_batch:
-                break
-        product_images = defaultdict(list)
-        [product_images[i.product].append(i) for i in images]
-        return product_images
-
-    def get_barcode(self, obj):
-        """
-        # The barcode uniquely identifying a
-        # certain product line across
-        remote_id_attribute = ["attributes","barcode"], ["sku"]
-        :param obj:
-        :return: String (required)
-        """
-        remote_id_attribute = self.integration.channel.conf.get(
-            "remote_id_attribute")
-        if remote_id_attribute:
-            return self.get_reduce_data(remote_id_attribute, obj.__dict__)
-        return obj.sku
-
-    @staticmethod
-    def get_reduce_data(code, value):
-        try:
-            data = functools.reduce(
-                lambda d, key: d.get(key, None) if isinstance(d,
-                                                              dict) else None,
-                code.split("__"), value)
-            return data
-        except TypeError:
-            return None
-
-    def _update_batch_request(self, model_items_by_content):
-        object_list = []
-        for key, model_items in model_items_by_content.items():
-            if isinstance(model_items, dict):
-                model_items_obj = [value for key, value in model_items.items()]
-            else:
-                model_items_obj = []
-            objects = self.create_batch_objects(data=model_items_obj,
-                                                content_type=key)
-            object_list.extend(objects)
-        self.update_batch_request(objects_data=object_list)
-
-    def update_other_objects(self, channel_items_by_object_id: dict,
-                             model_items_by_content: dict):
-        for key, model_items in model_items_by_content.items():
-            for reference_object_id, model_item in model_items.items():
-                if not isinstance(model_item, list):
-                    model_item = [model_item]
-                for mi in model_item:
-                    try:
-                        remote_item = channel_items_by_object_id[
-                            reference_object_id]
-                    except KeyError:
-                        mi.failed_reason_type = FailedReasonType.channel_app.value
-                        message = f'This item information was not sent from the channel. ID is {reference_object_id}'
-                        self.failed_object_list.append((mi, key, message))
-                        continue
-
-                    if remote_item.status == ResponseStatus.fail:
-                        mi.failed_reason_type = FailedReasonType.channel_app.value
-                        self.failed_object_list.append(
-                            (mi, key, remote_item.message))
-                    else:
-                        mi.remote_id = remote_item.remote_id
-
-    def get_channel_items_by_reference_object_ids(self, channel_response,
-                                                  model_items_by_content,
-                                                  integration_actions):
-        raise NotImplementedError
-
-    def process_item(self, channel_response):
-        # [1] Get all integration actions of this batch request
-        batch_integration_actions = self.get_integration_actions_to_processing()
-        if not batch_integration_actions:
-            raise Exception("No records was found not with BatchRequest")
-
-        # [2] Group integration actions by content type and each object_ids of them
-        integration_items_by_content = self.group_integration_actions_by_content_type(
-            batch_integration_actions)
-        # [3] Group model items by content type and their object id
-        model_items_by_content = self.group_model_items_by_content_type(
-            integration_items_by_content)
-
-        # [4] Link Omnitron and Channel items
-        channel_items_by_product_id = self.get_channel_items_by_reference_object_ids(
-            channel_response=channel_response,
-            model_items_by_content=model_items_by_content,
-            integration_actions=batch_integration_actions)
-
-        # [5] Updates statuses of related models by monkey patching them
-        # Creates failed_object_list
-        self.update_other_objects(channel_items_by_product_id,
-                                  model_items_by_content)
-
-        # [6] update batch request and object list
-        self._update_batch_request(model_items_by_content)