wizata-dsapi 2.2.0.dev28__tar.gz → 2.2.0.dev30__tar.gz

{wizata_dsapi-2.2.0.dev28 → wizata_dsapi-2.2.0.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.2.0.dev28
+Version: 2.2.0.dev30
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

{wizata_dsapi-2.2.0.dev28 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi/__init__.py

@@ -81,6 +81,10 @@ from .inventory import (InventoryBalance, InventoryStorage, InventoryStorageData
                         InventoryHistoryEvent, HISTORY_MOVEMENT, HISTORY_COUNT, round_quantity,
                         INVENTORY_MOVEMENTS, INVENTORY_BALANCES, INVENTORY_STOCK,
                         PRODUCT_TAG, PRODUCT_MESSAGE_KEY)
+from .planned_movement import (PlannedMovement, PlannedMovementSet, PLANNED_MOVEMENT_TYPES,
+                               PLANNED_MOVEMENT_SNAPSHOT_TYPES, PLANNED_MOVEMENT_DATED_TYPES,
+                               planned_movement_direction, is_dated_planned_movement)
+from .inventory_availability import InventoryAvailability, InventoryAvailabilityProduct, InventoryProjectionDay
 from .dashboard import Dashboard, DashboardType
 from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
 from .graylog_log import GraylogLog

wizata_dsapi-2.2.0.dev30/wizata_dsapi/inventory_availability.py

@@ -0,0 +1,138 @@
+"""
+Production Planner availability (DEV-6137, epic DEV-6044, release 12.2).
+
+What a facility can still promise, per product, and how its stock is projected over the
+next days. Computed on read from the stock (balances + movements) and the planned
+movements (DEV-6136); nothing here is stored.
+
+- ``total``: stock under the facility, read at the moment of the last availability
+  snapshot written (``snapshot_as_of``), so the figures below hold at one moment and ATP
+  matches the source's.
+- ``allocated``, ``hold``, ``open_demand``: the snapshot's figures (``allocated``,
+  ``hold``, ``openDemand`` planned movements). Without a snapshot they come from the open
+  customer order lines (picked not shipped, ordered not picked) and ``from_snapshot`` is
+  False.
+- ``available`` = total - allocated - hold; ``atp`` = available - open demand.
+- ``dated``: the unpicked part of the open customer order lines, capped at the open
+  demand (lines are read more often than the snapshot); ``undated`` = open demand - dated,
+  due at once.
+- ``projection``: one entry per day of the horizon, the level at the end of the day =
+  available - undated - dated due by then + supply (open work and purchase orders) due by
+  then. ``net_requirement`` is the lowest level when it is below zero.
+"""
+
+from datetime import date, datetime
+from typing import Optional
+
+from .inventory import _ts_in, _ts_out, _uuid_str
+
+
+def _date_in(value):
+    if value is None or isinstance(value, date):
+        return value
+    return date.fromisoformat(str(value)[:10])
+
+
+class InventoryProjectionDay:
+    """The projected level at the end of ``day``, with what comes in and goes out that day."""
+
+    def __init__(self, day=None, incoming: float = None, outgoing: float = None, level: float = None):
+        self.day: Optional[date] = _date_in(day)
+        self.incoming = incoming
+        self.outgoing = outgoing
+        self.level = level
+
+    def to_dict(self) -> dict:
+        return {"date": self.day.isoformat() if self.day else None, "incoming": self.incoming,
+                "outgoing": self.outgoing, "level": self.level}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryProjectionDay":
+        return cls(day=data.get("date"), incoming=data.get("incoming"), outgoing=data.get("outgoing"),
+                   level=data.get("level"))
+
+
+class InventoryAvailabilityProduct:
+    """One product's availability at a facility, in ``unit`` (its stock total's unit)."""
+
+    def __init__(self, key: str = None, name: str = None, unit=None, unit_symbol: str = None):
+        self.key = key
+        self.name = name
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol = unit_symbol
+        self.total: Optional[float] = None
+        self.allocated: Optional[float] = None
+        self.hold: Optional[float] = None
+        self.open_demand: Optional[float] = None
+        self.available: Optional[float] = None
+        self.atp: Optional[float] = None
+        self.dated: Optional[float] = None
+        self.undated: Optional[float] = None
+        self.demand_explained: Optional[float] = None
+        self.allocation_explained: Optional[float] = None
+        self.supply: Optional[float] = None
+        self.net_requirement: Optional[float] = None
+        self.lowest: Optional[InventoryProjectionDay] = None
+        self.projection: list = []
+        self.from_snapshot: bool = False
+
+    _NUMBERS = (("total", "total"), ("allocated", "allocated"), ("hold", "hold"), ("openDemand", "open_demand"),
+                ("available", "available"), ("atp", "atp"), ("dated", "dated"), ("undated", "undated"),
+                ("demandExplained", "demand_explained"), ("allocationExplained", "allocation_explained"),
+                ("supply", "supply"), ("netRequirement", "net_requirement"))
+
+    def to_dict(self) -> dict:
+        obj = {"product": self.key, "name": self.name, "unit": self.unit, "unitSymbol": self.unit_symbol}
+        for json_name, attr in self._NUMBERS:
+            obj[json_name] = getattr(self, attr)
+        obj["fromSnapshot"] = self.from_snapshot
+        obj["lowest"] = self.lowest.to_dict() if self.lowest is not None else None
+        obj["projection"] = [day.to_dict() for day in self.projection]
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryAvailabilityProduct":
+        obj = cls(key=data.get("product"), name=data.get("name"), unit=data.get("unit"),
+                  unit_symbol=data.get("unitSymbol"))
+        for json_name, attr in cls._NUMBERS:
+            setattr(obj, attr, data.get(json_name))
+        obj.from_snapshot = bool(data.get("fromSnapshot"))
+        obj.lowest = InventoryProjectionDay.from_dict(data["lowest"]) if data.get("lowest") else None
+        obj.projection = [InventoryProjectionDay.from_dict(d) for d in data.get("projection") or []]
+        return obj
+
+    def __repr__(self) -> str:
+        return (f"InventoryAvailabilityProduct({self.key!r}, total={self.total}, atp={self.atp}, "
+                f"net_requirement={self.net_requirement})")
+
+
+class InventoryAvailability:
+    """
+    Availability of a facility's products at ``as_of`` (DEV-6137). ``snapshot_as_of`` is the
+    moment of the last availability snapshot written at or before it (None without one):
+    the stock and the snapshot's figures are read there.
+    """
+
+    def __init__(self, facility: str = None, as_of=None, snapshot_as_of=None, horizon_days: int = None):
+        self.facility = facility
+        self.as_of: Optional[datetime] = _ts_in(as_of)
+        self.snapshot_as_of: Optional[datetime] = _ts_in(snapshot_as_of)
+        self.horizon_days = horizon_days
+        self.products: list = []
+
+    def product(self, key: str) -> Optional[InventoryAvailabilityProduct]:
+        return next((p for p in self.products if p.key == key), None)
+
+    def to_dict(self) -> dict:
+        return {"facility": self.facility,
+                "asOf": _ts_out(self.as_of) if isinstance(self.as_of, datetime) else self.as_of,
+                "snapshotAsOf": _ts_out(self.snapshot_as_of) if isinstance(self.snapshot_as_of, datetime)
+                else self.snapshot_as_of,
+                "horizonDays": self.horizon_days, "products": [p.to_dict() for p in self.products]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryAvailability":
+        obj = cls(facility=data.get("facility"), as_of=data.get("asOf"), snapshot_as_of=data.get("snapshotAsOf"),
+                  horizon_days=data.get("horizonDays"))
+        obj.products = [InventoryAvailabilityProduct.from_dict(p) for p in data.get("products") or []]
+        return obj

wizata_dsapi-2.2.0.dev30/wizata_dsapi/planned_movement.py

@@ -0,0 +1,195 @@
+"""
+Production Planner planned movements (epic DEV-6044, DEV-6136, release 12.2).
+
+A planned movement is a quantity of a product the planner must not count as free stock:
+
+- stock the system of record has reserved or blocked, reported by its availability
+  snapshot (``allocated``, ``hold``, ``openDemand``: one row per product, no date);
+- or a movement expected to happen (``customerOrder``, ``workOrder``,
+  ``workOrderComponent``, ``purchaseOrder``, ``forecast``: one row per document line,
+  due at a date).
+
+When an expected movement happens it becomes a real one (a shipped or production
+movement on an inventoryMovement DataPoint) and the planned one closes. Stock itself is
+unchanged: movements and balances stay what they are.
+
+A sync writes the **full set** of one source, type and facility at a moment (``asOf``):
+a changed row gets a new version, a row missing from the set is closed. Every version is
+kept (``validFrom`` / ``validTo``), so what was planned at any past moment can be read
+again.
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from .inventory import _ts_in, _ts_out, _uuid_str
+
+#: type -> (direction, dated). Snapshot types carry one row per product and no date.
+PLANNED_MOVEMENT_TYPES = {
+    "allocated": ("out", False),
+    "hold": ("out", False),
+    "openDemand": ("out", False),
+    "customerOrder": ("out", True),
+    "workOrder": ("in", True),
+    "workOrderComponent": ("out", True),
+    "purchaseOrder": ("in", True),
+    "forecast": ("out", True),
+}
+PLANNED_MOVEMENT_SNAPSHOT_TYPES = tuple(t for t, (_, dated) in PLANNED_MOVEMENT_TYPES.items() if not dated)
+PLANNED_MOVEMENT_DATED_TYPES = tuple(t for t, (_, dated) in PLANNED_MOVEMENT_TYPES.items() if dated)
+PLANNED_MOVEMENT_DIRECTIONS = ("in", "out")
+
+
+def planned_movement_direction(movement_type: str) -> str:
+    """``in`` or ``out`` for a type; a ValueError for an unknown one."""
+    if movement_type not in PLANNED_MOVEMENT_TYPES:
+        raise ValueError(f"type must be one of {', '.join(PLANNED_MOVEMENT_TYPES)}, not {movement_type!r}"[:300])
+    return PLANNED_MOVEMENT_TYPES[movement_type][0]
+
+
+def is_dated_planned_movement(movement_type: str) -> bool:
+    """True for a type with one row per document line and a due date."""
+    planned_movement_direction(movement_type)
+    return PLANNED_MOVEMENT_TYPES[movement_type][1]
+
+
+class PlannedMovement:
+    """
+    One version of one planned movement. PostgreSQL ``"PlannedMovement"`` (alembic 0032).
+
+    - ``source`` names the system it comes from (e.g. ``asc``), ``type`` one of
+      :data:`PLANNED_MOVEMENT_TYPES`, ``facility`` the Twin (hardware id) it applies to.
+    - A snapshot type is one row per ``product``. A dated type is one row per
+      ``document`` (as the source writes it) and ``line`` (its position), due at ``due``.
+    - Quantities: ``planned`` in total, ``in_progress`` already started (picked),
+      ``done`` already happened (shipped). What remains open is ``planned - done``; it
+      is never stored.
+    - ``unit``: on write, the backend unit id the quantities are sent in (of the
+      product's category); they are converted to the product's default unit. On read,
+      the unit they are stored in: the product's default unit when the row was written,
+      None when it had none.
+    - ``valid_from`` / ``valid_to``: when this version was true. ``valid_to`` is None
+      while it still is.
+    """
+
+    @classmethod
+    def route(cls):
+        return "planner/plannedmovements"
+
+    def __init__(self, product: str = None, planned: float = None, document: str = None, line: int = None,
+                 due=None, in_progress: float = None, done: float = None, partner: str = None,
+                 movement_type: str = None, source: str = None, facility: str = None,
+                 direction: str = None, unit=None, movement_id=None):
+        self.id: Optional[str] = _uuid_str(movement_id)
+        self.source: Optional[str] = source
+        self.type: Optional[str] = movement_type
+        self.facility: Optional[str] = facility
+        self.document: Optional[str] = document
+        self.line: Optional[int] = line
+        self.direction: Optional[str] = direction
+        self.product: Optional[str] = product
+        self.partner: Optional[str] = partner
+        self.due: Optional[datetime] = _ts_in(due)
+        self.planned: Optional[float] = planned
+        self.in_progress: Optional[float] = in_progress
+        self.done: Optional[float] = done
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.valid_from: Optional[datetime] = None
+        self.valid_to: Optional[datetime] = None
+        self.created_at: Optional[datetime] = None
+        self.created_by: Optional[str] = None
+
+    @property
+    def is_open(self) -> bool:
+        """This version is still true."""
+        return self.valid_to is None
+
+    def key(self) -> tuple:
+        """What identifies the row within its set: the product for a snapshot type, the
+        document and line for a dated one."""
+        if self.type in PLANNED_MOVEMENT_TYPES and not PLANNED_MOVEMENT_TYPES[self.type][1]:
+            return (self.product,)
+        return self.document, self.line
+
+    def to_dict(self) -> dict:
+        obj = {}
+        for name, value in (("id", self.id), ("source", self.source), ("type", self.type),
+                            ("facility", self.facility), ("document", self.document), ("line", self.line),
+                            ("direction", self.direction), ("product", self.product),
+                            ("partner", self.partner), ("planned", self.planned),
+                            ("inProgress", self.in_progress), ("done", self.done), ("unit", self.unit),
+                            ("createdBy", self.created_by)):
+            if value is not None:
+                obj[name] = value
+        for name, value in (("due", self.due), ("validFrom", self.valid_from), ("validTo", self.valid_to),
+                            ("createdAt", self.created_at)):
+            if value is not None:
+                obj[name] = _ts_out(value) if isinstance(value, datetime) else value
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PlannedMovement":
+        obj = cls()
+        obj.id = _uuid_str(data.get("id"))
+        obj.source = data.get("source")
+        obj.type = data.get("type")
+        obj.facility = data.get("facility")
+        obj.document = data.get("document")
+        obj.line = data.get("line")
+        obj.direction = data.get("direction")
+        obj.product = data.get("product")
+        obj.partner = data.get("partner")
+        obj.due = _ts_in(data.get("due"))
+        obj.planned = data.get("planned")
+        obj.in_progress = data.get("inProgress", data.get("in_progress"))
+        obj.done = data.get("done")
+        obj.unit = _uuid_str(data.get("unit"))
+        obj.valid_from = _ts_in(data.get("validFrom") or data.get("valid_from"))
+        obj.valid_to = _ts_in(data.get("validTo") or data.get("valid_to"))
+        obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
+        obj.created_by = data.get("createdBy") or data.get("created_by")
+        return obj
+
+    def api_id(self) -> str:
+        return self.id
+
+    def __repr__(self) -> str:
+        return (f"PlannedMovement(type={self.type!r}, product={self.product!r}, document={self.document!r}, "
+                f"line={self.line!r}, planned={self.planned!r}, done={self.done!r})")
+
+
+class PlannedMovementSet:
+    """
+    The outcome of writing one full set (source, type, facility) at ``as_of``: how many
+    rows were ``created``, ``changed`` (a new version), ``unchanged`` and ``closed``
+    (missing from the set). ``open`` is how many rows the set holds afterwards.
+    """
+
+    def __init__(self, source: str = None, movement_type: str = None, facility: str = None, as_of=None,
+                 created: int = 0, changed: int = 0, unchanged: int = 0, closed: int = 0, open_rows: int = 0):
+        self.source = source
+        self.type = movement_type
+        self.facility = facility
+        self.as_of: Optional[datetime] = _ts_in(as_of)
+        self.created = created
+        self.changed = changed
+        self.unchanged = unchanged
+        self.closed = closed
+        self.open = open_rows
+
+    def to_dict(self) -> dict:
+        return {"source": self.source, "type": self.type, "facility": self.facility,
+                "asOf": _ts_out(self.as_of) if isinstance(self.as_of, datetime) else self.as_of,
+                "created": self.created, "changed": self.changed, "unchanged": self.unchanged,
+                "closed": self.closed, "open": self.open}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PlannedMovementSet":
+        return cls(source=data.get("source"), movement_type=data.get("type"), facility=data.get("facility"),
+                   as_of=data.get("asOf"), created=data.get("created", 0), changed=data.get("changed", 0),
+                   unchanged=data.get("unchanged", 0), closed=data.get("closed", 0),
+                   open_rows=data.get("open", 0))
+
+    def __repr__(self) -> str:
+        return (f"PlannedMovementSet(type={self.type!r}, facility={self.facility!r}, created={self.created}, "
+                f"changed={self.changed}, unchanged={self.unchanged}, closed={self.closed}, open={self.open})")

wizata_dsapi-2.2.0.dev30/wizata_dsapi/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.0.dev30"

{wizata_dsapi-2.2.0.dev28 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi/wizata_dsapi_client.py

@@ -58,6 +58,8 @@ import ast
 from .deployment import Deployment, DeploymentStatus
 from .product import ProductKind, Product, ProductComponent
 from .inventory import InventoryBalance, InventoryStorage, InventoryStock, InventoryCount, InventoryHistory
+from .inventory_availability import InventoryAvailability
+from .planned_movement import PlannedMovement, PlannedMovementSet
 from .connection import EdgeDeviceKey
 from .edge_config import EdgeConfig
 from .api_config import _registry
@@ -3169,6 +3171,101 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         response = self._planner_request("POST", "planner/inventory/history", body=body)
         return InventoryHistory.from_dict(response.json())
 
+    # Production Planner - planned movements (DEV-6136)
+
+    def set_planned_movements(self, source: str, movement_type: str, facility: str, as_of,
+                              movements: list) -> PlannedMovementSet:
+        """
+        Write the full set of planned movements of one source, type and facility as it is
+        at ``as_of``, all or none: afterwards the set holds exactly ``movements``. A row
+        whose values changed gets a new version, a row left out is closed at ``as_of``, an
+        empty list closes them all. Every version is kept.
+
+        Sets are written in time order: an ``as_of`` before the set's last write is a 409.
+        Writing the same ``as_of`` again corrects that write.
+
+        :param source: the system the rows come from, e.g. ``asc``.
+        :param movement_type: ``allocated``, ``hold``, ``openDemand`` (one row per product,
+            from the source's availability snapshot), or ``customerOrder``, ``workOrder``,
+            ``workOrderComponent``, ``purchaseOrder``, ``forecast`` (one row per
+            ``document`` and ``line``, with a ``due`` date).
+        :param facility: hardware id of the Twin the rows apply to.
+        :param as_of: datetime or ISO 8601: when the source held this set.
+        :param movements: PlannedMovement list (or dicts). Quantities: ``planned``, and
+            ``in_progress`` / ``done`` for dated types, in the product's default unit unless
+            ``unit`` names another unit of its category.
+        :return: PlannedMovementSet: how many rows were created, changed, unchanged, closed.
+        """
+        if isinstance(as_of, datetime.datetime):
+            if as_of.tzinfo is None:
+                as_of = as_of.replace(tzinfo=datetime.timezone.utc)
+            as_of = as_of.isoformat()
+        body = {"source": source, "type": movement_type, "facility": facility, "asOf": as_of,
+                "movements": [m.to_dict() if isinstance(m, PlannedMovement) else m for m in movements or []]}
+        response = self._planner_request("POST", "planner/plannedmovements/", body=body)
+        return PlannedMovementSet.from_dict(response.json())
+
+    def search_planned_movements(self, search_query=None) -> PagedQueryResult:
+        """
+        List planned movements: the open rows by default, sorted by due date.
+
+        :param search_query: SearchQuery or dict; filters on ``source``, ``type``,
+            ``facility``, ``product``, ``document``, ``partner`` (eq / in), ``due`` (eq / gte /
+            gt / lt / lte), ``asOf`` (the rows as they were at that moment) or ``history``
+            (true: every version).
+        :return: PagedQueryResult with PlannedMovement results.
+        """
+        if search_query is None:
+            search_query = SearchQuery()
+        elif isinstance(search_query, dict):
+            search_query = SearchQuery.from_dict(search_query)
+        response = self._planner_request("POST", "planner/plannedmovements/search", body=search_query.to_dict())
+        return PagedQueryResult.from_dict(response.json(), dto_class=PlannedMovement)
+
+    def delete_planned_movements(self, source: str, movement_type: str, facility: str) -> int:
+        """
+        Delete every version of every row of one set (e.g. a sync pointed at the wrong
+        facility). To close the rows and keep their history, write an empty set instead.
+
+        :return: how many rows were deleted; 0 when the set held nothing.
+        """
+        response = self._planner_request("DELETE", "planner/plannedmovements/",
+                                         params={"source": source, "type": movement_type, "facility": facility},
+                                         expected=(200, 404))
+        return response.json().get("deleted", 0) if response.status_code == 200 else 0
+
+    def get_inventory_availability(self, facility: str, as_of=None, products: list = None,
+                                   horizon_days: int = None, sources: list = None) -> InventoryAvailability:
+        """
+        What a facility can still promise per product, and its stock projected per day
+        (DEV-6137). The stock under the facility twin and its children and the figures of the
+        last availability snapshot (``allocated``, ``hold``, ``openDemand`` planned movements)
+        are read at that snapshot's moment (``snapshot_as_of``): available = total - allocated
+        - hold, ATP = available - open demand. The open customer order lines date the demand
+        (capped at the open demand; the rest is due at once) and the open work and purchase
+        orders come in when due. Without a snapshot, the lines give allocated and open demand.
+
+        :param facility: hardware id of the facility Twin.
+        :param as_of: datetime, ISO 8601, epoch ms or a relative ``now-1d``; default now.
+        :param products: product keys to keep.
+        :param horizon_days: days projected (UTC days, today first); default 14, at most 120.
+        :param sources: keep the planned movements of those sources.
+        """
+        body = {"facility": facility}
+        if as_of is not None:
+            if isinstance(as_of, datetime.datetime):
+                if as_of.tzinfo is None:
+                    as_of = as_of.replace(tzinfo=datetime.timezone.utc)
+                as_of = as_of.isoformat()
+            body["asOf"] = as_of
+        for name, value in (("products", products), ("sources", sources)):
+            if value is not None:
+                body[name] = list(value)
+        if horizon_days is not None:
+            body["horizonDays"] = horizon_days
+        response = self._planner_request("POST", "planner/inventory/availability", body=body)
+        return InventoryAvailability.from_dict(response.json())
+
     # ------------------------------------------------------------ edge (DEV-6013/6014)
 
     @staticmethod

{wizata_dsapi-2.2.0.dev28 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.2.0.dev28
+Version: 2.2.0.dev30
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

{wizata_dsapi-2.2.0.dev28 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ wizata_dsapi/group_system.py
 wizata_dsapi/ilogger.py
 wizata_dsapi/insight.py
 wizata_dsapi/inventory.py
+wizata_dsapi/inventory_availability.py
 wizata_dsapi/mlmodel.py
 wizata_dsapi/mobile_asset.py
 wizata_dsapi/model_toolkit.py
@@ -40,6 +41,7 @@ wizata_dsapi/notification.py
 wizata_dsapi/paged_query_result.py
 wizata_dsapi/pipeline.py
 wizata_dsapi/pipeline_image.py
+wizata_dsapi/planned_movement.py
 wizata_dsapi/plot.py
 wizata_dsapi/product.py
 wizata_dsapi/python_package.py

wizata_dsapi-2.2.0.dev28/wizata_dsapi/version.py

@@ -1 +0,0 @@
-__version__ = "2.2.0.dev28"