deepfos 1.1.30__tar.gz → 1.1.32__tar.gz

{deepfos-1.1.30 → deepfos-1.1.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepfos
-Version: 1.1.30
+Version: 1.1.32
 Summary: Collecions of useful and handy tools for deepfos platform
 Home-page: http://py.deepfos.com
 Author: deepfos-python-team

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-03-19T02:19:15+0000",
+ "date": "2024-04-08T07:12:04+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "adeda255af80779e2cbe13668d58404bbeecee0e",
- "version": "1.1.30"
+ "full-revisionid": "2eb652409a767c757a4324b2ceb60a88d649f355",
+ "version": "1.1.32"
 }
 '''  # END VERSION_JSON
 

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/api/models/deepmodel.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, Any
 
 from pydantic import Field
 
@@ -148,7 +148,7 @@ class QueryResultObjectInfo(BaseModel):
 
 class QueryResult(BaseModel):
     objectInfos: Optional[List[QueryResultObjectInfo]]
-    json_: List = Field(default_factory=list, alias='json')
+    json_: Any = Field(alias='json')
 
 
 ObjectParam.update_forward_refs()

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/api/space.py

@@ -379,7 +379,7 @@ class SpaceUserAPI(ChildAPI):
 
         批量获取用户组内所有用户信息（含子集组用户）依赖平台版本2.6.7
         """
-        return {'param': {'groupIds': groupIds}}
+        return {'body': {'groupIds': groupIds}}
 
     @get('query')
     def query(self, userId: str, status: str = None) -> Union[SingleUserVo, Awaitable[SingleUserVo]]:

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/db/edb.py

@@ -1,46 +1,45 @@
-from edgedb import AsyncIOClient, errors, enums, describe
-from edgedb.abstract import DescribeContext
-from edgedb.asyncio_client import AsyncIOConnection # noqa
-from edgedb.protocol import protocol
+import asyncio
+
+from edgedb import AsyncIOClient, errors, enums, describe, abstract
+from edgedb.abstract import (
+    DescribeContext, QueryContext, QueryWithArgs,
+    _query_opts    # noqa
+)
+from edgedb.asyncio_client import (
+    AsyncIOConnection, AsyncIOIteration,    # noqa
+    AsyncIORetry
+)
 
 from deepfos import OPTION
 
 __all__ = ['create_async_client']
 
 
-def collect_output_frame(des: describe.ObjectType):
-    if isinstance(des, describe.ObjectType):
+def collect_output_frame(ele_desc: describe.AnyType):
+    if isinstance(ele_desc, describe.ObjectType):
+        return {
+            field: collect_output_frame(element.type)
+            for field, element in ele_desc.elements.items()
+            if element.is_implicit == 0
+        }
+    if isinstance(ele_desc, describe.ArrayType):
+        return collect_output_frame(ele_desc.element_type)
+    if isinstance(ele_desc, describe.NamedTupleType):
         return {
-            field: ele.type.name
-            for field, ele in des.elements.items()
-            if ele.is_implicit == 0
+            field: collect_output_frame(ele_type)
+            for field, ele_type in ele_desc.element_types.items()
         }
-    # Scalar or ArrayType
-    return {}
+    if isinstance(ele_desc, describe.TupleType):
+        return [collect_output_frame(ele_type) for ele_type in ele_desc.element_types]
+    return ele_desc.name
 
 
 class _AsyncEdgeDBConnection(AsyncIOConnection):
-    async def _execute(self, execute_context) -> None:
-        await self._protocol.execute(
-            query=execute_context.query.query,
-            args=execute_context.query.args,
-            kwargs=execute_context.query.kwargs,
-            reg=execute_context.cache.codecs_registry,
-            qc=execute_context.cache.query_cache,
-            output_format=protocol.OutputFormat.NONE,
-            allow_capabilities=enums.Capability.MODIFICATIONS,
-            state=(
-                execute_context.state.as_dict()
-                if execute_context.state else None
-            ),
-        )
-
-    async def raw_query(self, query_context):
+    async def raw_query(self, query_context, capabilities=enums.Capability.NONE):
         if self.is_closed():
             await self.connect()
 
         reconnect = False
-        capabilities = None
         i = 0
         args = dict(
             query=query_context.query.query,
@@ -51,7 +50,7 @@ class _AsyncEdgeDBConnection(AsyncIOConnection):
             output_format=query_context.query_options.output_format,
             expect_one=query_context.query_options.expect_one,
             required_one=query_context.query_options.required_one,
-            allow_capabilities=enums.Capability.NONE,
+            allow_capabilities=capabilities,
         )
         if query_context.state is not None:
             args["state"] = query_context.state.as_dict()
@@ -115,6 +114,43 @@ class _AsyncEdgeDBConnection(AsyncIOConnection):
                 reconnect = self.is_closed()
 
 
+class _AsyncIOIteration(AsyncIOIteration):
+    async def _execute(self, query_context: abstract.QueryContext):
+        with self._exclusive():
+            await self._ensure_transaction()
+            return await self._connection.raw_query(
+                query_context, enums.Capability.MODIFICATIONS
+            )
+
+    async def execute(self, commands: str, *args, **kwargs):
+        return await self._execute(QueryContext(
+            query=QueryWithArgs(commands, args, kwargs),
+            cache=self._get_query_cache(),
+            query_options=_query_opts,
+            retry_options=self._get_retry_options(),
+            state=self._get_state(),
+        ))
+
+
+class _AsyncIORetry(AsyncIORetry):
+    async def __anext__(self):
+        # Note: when changing this code consider also
+        # updating Retry.__next__.
+        if self._done:
+            raise StopAsyncIteration
+        if self._next_backoff:
+            await asyncio.sleep(self._next_backoff)
+        self._done = True
+        iteration = _AsyncIOIteration(self, self._owner, self._iteration)
+        self._iteration += 1
+        return iteration
+
+
+class _AsyncIOClient(AsyncIOClient):
+    def transaction(self) -> _AsyncIORetry:
+        return _AsyncIORetry(self)
+
+
 # All deprecated space in v3dev & v3test & alpha
 deprecated_space = [
     'ulqtqb',
@@ -137,7 +173,7 @@ deprecated_space = [
 def create_async_client(default_module=None):
     space = OPTION.api.header['space']
     dbname = None if space in deprecated_space else f"deepmodel_space{space}"
-    cli = AsyncIOClient(
+    cli = _AsyncIOClient(
         connection_class=_AsyncEdgeDBConnection,
         max_concurrency=None,
         dsn=OPTION.edgedb.dsn,

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/element/deepmodel.py

@@ -243,7 +243,7 @@ class BaseField(FieldInfo):
         # df[self.col_name] = df[self.col_name].astype(self.dtype, errors='ignore')
         pass
 
-    def cast(self, df: pd.DataFrame, field_name: str):
+    def cast(self, df: pd.DataFrame, field_name: str, direct_access: bool = True):
         """
         对 :class:`Dataframe` 对应的列作类型转换。
         一般在获取 :class:`Dataframe` 时使用。
@@ -261,7 +261,7 @@ class FieldDateTime(BaseField):
     def extra_fit(self, df: pd.DataFrame, field_name: str):
         df[field_name] = df[field_name].apply(self.format_datetime)
 
-    def cast(self, df: pd.DataFrame, field_name: str):
+    def cast(self, df: pd.DataFrame, field_name: str, direct_access: bool = True):
         df[field_name] = pd.to_datetime(df[field_name], errors='ignore')
 
 
@@ -281,11 +281,11 @@ class FieldJson(BaseField):
             return data
         return json.dumps(data)
 
-    def cast(self, df: pd.DataFrame, field_name: str):
+    def cast(self, df: pd.DataFrame, field_name: str, direct_access: bool = True):
         # std::json needed to be cast only when data is from http
         # since json value will be converted to json string(type: str)
         # in edgedb python protocol
-        if not ONLINE_MODE:
+        if not direct_access:
             df[field_name] = df[field_name].apply(self.format_json)
 
 
@@ -295,17 +295,17 @@ class FieldInt(FieldString):
             return pd.NA
         return str(int(data))
 
-    def cast(self, df: pd.DataFrame, field_name: str):
+    def cast(self, df: pd.DataFrame, field_name: str, direct_access: bool = True):
         df[field_name] = df[field_name].astype(pd.Int64Dtype(), errors='ignore')
 
 
 class FieldDecimal(FieldString):
-    def cast(self, df: pd.DataFrame, field_name: str):
+    def cast(self, df: pd.DataFrame, field_name: str, direct_access: bool = True):
         df[field_name] = df[field_name].astype(pd.Float64Dtype(), errors='ignore')
 
 
 class FieldBool(BaseField):
-    def cast(self, df: pd.DataFrame, field_name: str):
+    def cast(self, df: pd.DataFrame, field_name: str, direct_access: bool = True):
         df[field_name] = df[field_name].astype(pd.BooleanDtype(), errors='ignore')
 
 
@@ -362,10 +362,10 @@ class ObjectStructure:
 
         return df[valid_fields]
 
-    def cast(self, df: pd.DataFrame):
+    def cast(self, df: pd.DataFrame, direct_access: bool = True):
         for field in df.columns:
             if field in self.fields:
-                self.fields[field].cast(df, field)
+                self.fields[field].cast(df, field, direct_access)
 
 
 def _iter_link_prop_assign(link, business_key, prop_name, prop_type, is_multi):
@@ -545,7 +545,10 @@ def collect_frame_desc_structure(desc: Dict[str, str]):
     fields = [
         FieldInfo(
             name=name,
-            target=TargetField(name=tname or NOT_SCALAR)
+            target=TargetField(
+                name=tname
+                if isinstance(tname, str) else NOT_SCALAR
+            )
         )
         for name, tname in desc.items()
     ]
@@ -564,23 +567,25 @@ class _TxnConfig:
         self.txn_support = False
 
 
-if OPTION.edgedb.dsn:
-    ONLINE_MODE = True
-else:
-    ONLINE_MODE = False
-
-
 # -----------------------------------------------------------------------------
 # core
 class AsyncDeepModel(ElementBase[DeepModelAPI]):
     """DeepModel"""
 
-    def __init__(self):  # noqa
+    def __init__(self, direct_access: bool=True):  # noqa
         self._txn_ = ContextVar('QLTXN')
         self.appmodule = f"app{OPTION.api.header['app']}"
         self.spacemodule = f"space{OPTION.api.header['space']}"
-        if ONLINE_MODE:
+        self.direct_access = direct_access
+        if direct_access:
             self.client = create_async_client(default_module=self.appmodule)
+            if user_id := OPTION.api.header.get('user'):
+                self.client = self.client.with_globals(
+                    **{
+                        f'{self.spacemodule}::current_user_id':
+                        user_id
+                    }
+                )
         else:
             self.client = None
         self.alias = AliasGenerator()
@@ -687,7 +692,7 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
             
         """
 
-        if ONLINE_MODE:
+        if self.direct_access:
             logger.opt(lazy=True).debug(f"Query: [{ql}], \nkwargs: [{kwargs}].")
             async with self.client as cli:
                 _, result = await cli.query(ql, **kwargs)
@@ -723,9 +728,13 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
             :func:`query_object`, 执行ql查询语句，得到原始结果返回
 
         """
-        if ONLINE_MODE:
-            result = await self.query_object(ql, **kwargs)
-            return serutils.serialize(result)
+        if self.direct_access:
+            logger.opt(lazy=True).debug(f"Query: [{ql}], \nkwargs: [{kwargs}].")
+            async with self.client as cli:
+                frame_desc, result = await cli.query(ql, **kwargs)
+            return serutils.serialize(
+                result, ctx=serutils.Context(frame_desc=frame_desc)
+            )
 
         result = await self._http_query(ql, **kwargs)
         return result.json_
@@ -768,28 +777,35 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
             :func:`query_object`, 执行ql查询语句，得到原始结果返回
         
         """
-        if ONLINE_MODE:
+        if self.direct_access:
             async with self.client as cli:
                 frame_desc, data = await cli.query(ql, **kwargs)
-            data = pd.DataFrame(data=serutils.serialize(data))
-            # No object structure info
-            if not frame_desc:
+
+            data = pd.DataFrame(data=serutils.serialize(
+                data, ctx=serutils.Context(frame_desc=frame_desc)
+            ))
+            # Not records for dict-like
+            if not isinstance(frame_desc, dict):
                 return data
 
             structure = collect_frame_desc_structure(frame_desc)
         else:
             result = await self._http_query(ql, **kwargs)
-            data = pd.DataFrame(data=result.json_)
             # No object structure info
             if result.objectInfos is None:
-                return data
+                return pd.DataFrame(data=result.json_)
+
+            data = pd.DataFrame(
+                data=result.json_,
+                columns=[f.name for f in result.objectInfos[0].fields]
+            )
 
             structure = collect_query_result_structure(result.objectInfos[0])
 
         if data.empty:
             return pd.DataFrame(columns=structure.fields.keys())
 
-        structure.cast(data)
+        structure.cast(data, self.direct_access)
         return data
 
     query.__doc__ = query.__doc__ + DOC_ARGS_KWARGS
@@ -797,7 +813,11 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
     query_df.__doc__ = query_df.__doc__ + DOC_ARGS_KWARGS
 
     @txn_support
-    async def execute(self, qls: Union[str, List[str], List[QueryWithArgs]], **kwargs):
+    async def execute(
+        self,
+        qls: Union[str, List[str], List[QueryWithArgs]],
+        **kwargs
+    ) -> Optional[List]:
         """以事务执行多句ql
 
         Args:
@@ -814,10 +834,12 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
             seen_kwargs_key = set()
             for ql in qls:
                 if isinstance(ql, QueryWithArgs):
-                    if not ONLINE_MODE and ql.kwargs and seen_kwargs_key.intersection(
-                        ql.kwargs.keys()
+                    if (
+                        not self.direct_access
+                        and ql.kwargs
+                        and seen_kwargs_key.intersection(ql.kwargs.keys())
                     ):
-                        raise NotImplementedError('线下模式不支持重名variables')
+                        raise NotImplementedError('非直连模式不支持重名variables')
 
                     qls_with_args.append(ql)
                     if ql.kwargs:
@@ -828,19 +850,19 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
                 else:
                     raise TypeError(f'qls参数中出现类型非法成员：{type(ql)}')
 
-        await self._maybe_exec_qls(qls_with_args)
+        return await self._maybe_exec_qls(qls_with_args)
 
     execute.__doc__ = execute.__doc__ + DOC_ARGS_KWARGS
 
-    async def _execute(self, qls_with_args: List[QueryWithArgs]):
+    async def _execute(self, qls_with_args: List[QueryWithArgs]) -> List:
         self.alias.reset(BATCH_INSERT_KW)
-        if not ONLINE_MODE:
+        if not self.direct_access:
             kwargs = {}
             seen_kwargs_key = set()
 
             for ql in qls_with_args:
                 if ql.kwargs and seen_kwargs_key.intersection(ql.kwargs.keys()):
-                    raise NotImplementedError('线下模式不支持重名variables')
+                    raise NotImplementedError('非直连模式不支持重名variables')
                 if ql.kwargs:
                     kwargs.update(ql.kwargs)
                     seen_kwargs_key = seen_kwargs_key.union(ql.kwargs.keys())
@@ -855,9 +877,11 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
                 query=commands,
                 variables=self._prepare_variables(kwargs)
             )
-            self._maybe_handle_error(res.get('json'))
-            return
+            affected = res.get('json')
+            self._maybe_handle_error(affected)
+            return affected
 
+        result = []
         async with self.client as cli:
             async for tx in cli.transaction():
                 async with tx:
@@ -865,7 +889,13 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
                         logger.opt(lazy=True).debug(
                             f"Execute QL: [{ql.commands}], \nkwargs: [{ql.kwargs}]."
                         )
-                        await tx.execute(ql.commands, **ql.kwargs)
+                        desc, affected = await tx.execute(ql.commands, **ql.kwargs)
+                        result.append(serutils.serialize(
+                            affected, ctx=serutils.Context(frame_desc=desc)
+                        ))
+        if len(result) == 1:
+            return result[0]
+        return result
 
     @staticmethod
     def _maybe_handle_error(res):
@@ -874,17 +904,20 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
 
         if error := res.get('errors'):  # pragma: no cover
             ex_msg = error['message'].strip()
-            ex_code = error['code']
+            ex_code = int(error['code'])
             raise edgedb.EdgeDBError._from_code(ex_code, ex_msg)  # noqa
 
-    async def _maybe_exec_qls(self, qls_with_args: List[QueryWithArgs]):
+    async def _maybe_exec_qls(
+        self,
+        qls_with_args: List[QueryWithArgs]
+    ) -> Optional[List]:
         txn_conf = self._safe_get_txn_conf()
 
         if txn_conf.in_txn and self._txn_support_:
             txn_conf.qls.extend(qls_with_args)
             return
 
-        await self._execute(qls_with_args)
+        return await self._execute(qls_with_args)
 
     @txn_support
     async def insert_df(
@@ -895,7 +928,7 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
         chunksize: int = 500,
         enable_upsert: bool = False,
         update_fields: List[str] = None,
-    ):
+    ) -> None:
         """以事务执行基于DataFrame字段信息的批量插入数据
 
         Args:
@@ -1105,7 +1138,7 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
                 kwargs={kw_name: part.to_json(orient='records')}
             ))
 
-    def get_object(self, object_name):
+    def get_object(self, object_name) -> edgedb.Object:
         if object_name in self.user_objects:
             obj = self.user_objects[object_name]
         elif object_name in self.system_objects:
@@ -1123,7 +1156,7 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
         obj: Union[ObjectTypeFrame, TargetField],
         source_name: str = None,
         field_name: str = None
-    ):
+    ) -> str:
         # 如可在object结构的annotations中取业务主键，则优先取，否则走接口
         if obj.info and BUSINESS_KEY in obj.info:
             return obj.info[BUSINESS_KEY]
@@ -1248,6 +1281,36 @@ class AsyncDeepModel(ElementBase[DeepModelAPI]):
         finally:
             self._txn_.set(_TxnConfig())
 
+    @contextmanager
+    def with_globals(self, globals_):
+        if not self.direct_access:
+            try:
+                yield
+            finally:
+                raise NotImplemented('非直连模式不支持设置state信息')
+        else:
+            bak_cli = self.client
+            try:
+                self.client = self.client.with_globals(**globals_)
+                yield
+            finally:
+                self.client = bak_cli
+
+    @contextmanager
+    def without_globals(self, *global_names):
+        if not self.direct_access:
+            try:
+                yield
+            finally:
+                raise NotImplemented('非直连模式不支持设置state信息')
+        else:
+            bak_cli = self.client
+            try:
+                self.client = self.client.without_globals(*global_names)
+                yield
+            finally:
+                self.client = bak_cli
+
 
 class DeepModel(AsyncDeepModel, metaclass=SyncMeta):
     synchronize = ('query_object', 'query', 'query_df', 'execute', 'insert_df')
@@ -1262,7 +1325,11 @@ class DeepModel(AsyncDeepModel, metaclass=SyncMeta):
         def query_df(self, ql: str, **kwargs) -> pd.DataFrame:
             ...
 
-        def execute(self, qls: Union[str, List[str], List[QueryWithArgs]], **kwargs):
+        def execute(
+            self,
+            qls: Union[str, List[str], List[QueryWithArgs]],
+            **kwargs
+        ) -> Optional[List]:
             ...
 
         def insert_df(
@@ -1273,7 +1340,7 @@ class DeepModel(AsyncDeepModel, metaclass=SyncMeta):
             chunksize: int = 500,
             enable_upsert: bool = False,
             update_fields: List[str] = None,
-        ):
+        ) -> None:
             ...
 
     @contextmanager

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/element/dimension.py

@@ -38,7 +38,8 @@ from deepfos.lib.utils import unpack_expr, CIEnum, get_language_key_map
 from deepfos.lib.asynchronous import future_property
 from deepfos.lib.constant import (
     ROOT, ACCEPT_LANS, DFLT_NAME_COLUMN,
-    DFLT_PNAME_COLUMN, SHAREDMEMBER, INDEX_FIELD
+    DFLT_PNAME_COLUMN, SHAREDMEMBER, INDEX_FIELD,
+    SHAREDMEMBERV12, DFLT_PNAME_COLUMN_V12
 )
 
 __all__ = [
@@ -813,10 +814,6 @@ class AsyncDimension(ElementBase[DimensionAPI]):
         # split dataframe by existed data
         upd_df, add_df = await self._split_dimension_df(df[valid_columns])
 
-        if not self.is_v1_0_api:
-            to_v12 = {DFLT_PNAME_COLUMN: 'parentName', SHAREDMEMBER: 'sharedMember'}
-            upd_df = upd_df.rename(columns=to_v12)
-            add_df = add_df.rename(columns=to_v12)
         # modify operation column
         with self._local_memo():
             if strategy is Strategy.incr_replace:
@@ -918,7 +915,13 @@ class AsyncDimension(ElementBase[DimensionAPI]):
         self,
         df: pd.DataFrame
     ) -> Tuple[pd.DataFrame, pd.DataFrame]:
-        if SHAREDMEMBER not in df.columns:
+        shared_mbr_col = SHAREDMEMBER
+        pname_col = DFLT_PNAME_COLUMN
+        if not self.is_v1_0_api:
+            shared_mbr_col = SHAREDMEMBERV12
+            pname_col = DFLT_PNAME_COLUMN_V12
+
+        if shared_mbr_col not in df.columns:
             if self._strict:
                 existed_mbrs = self._member_memo
             else:
@@ -934,14 +937,14 @@ class AsyncDimension(ElementBase[DimensionAPI]):
 
         # -----------------------------------------------------------------------------
         # has shared member
-        df_shared: pd.DataFrame = df[df[SHAREDMEMBER]]
+        df_shared: pd.DataFrame = df[df[shared_mbr_col]]
         if self._strict:
             existed_mbrs = self._member_memo
 
             dup_sharedmbrs = []
             for idx, row in df_shared.iterrows():
-                for mbr in self._member_memo.getall(row[DFLT_NAME_COLUMN]):
-                    if mbr.sharedmember and mbr.parent_name == row[DFLT_PNAME_COLUMN]:
+                for mbr in self._member_memo.getall(row[DFLT_NAME_COLUMN], []):
+                    if mbr.sharedmember and mbr.parent_name == row[pname_col]:
                         dup_sharedmbrs.append(idx)
                         break
         else:
@@ -961,13 +964,13 @@ class AsyncDimension(ElementBase[DimensionAPI]):
             shared_memo = set(tuple(item) for item in existed_shared.to_numpy())
             dup_sharedmbrs = []
             for idx, row in df_shared.iterrows():
-                if (row[DFLT_NAME_COLUMN], row[DFLT_PNAME_COLUMN]) in shared_memo:
+                if (row[DFLT_NAME_COLUMN], row[pname_col]) in shared_memo:
                     dup_sharedmbrs.append(idx)
 
         # 在df中丢弃系统中已存在的共享节点
         df_shared_remain = df_shared[~df_shared.index.isin(dup_sharedmbrs)]
 
-        df_not_shared = df[~df[SHAREDMEMBER]]
+        df_not_shared = df[~df[shared_mbr_col]]
         existed_idx = df_not_shared[DFLT_NAME_COLUMN].isin(existed_mbrs)
         return df_not_shared.loc[existed_idx], \
             pd.concat([df_not_shared.loc[~existed_idx], df_shared_remain])

{deepfos-1.1.30 → deepfos-1.1.32}/deepfos/lib/constant.py

@@ -6,6 +6,11 @@ DFLT_DATA_COLUMN = 'data'
 DFLT_NAME_COLUMN = 'name'
 DFLT_PNAME_COLUMN = 'parent_name'
 SHAREDMEMBER = 'sharedmember'
+
+SHAREDMEMBERV12 = 'sharedMember'
+DFLT_PNAME_COLUMN_V12 = 'parentName'
+
+
 VIEW = "View"
 VIEW_DICT = CaseInsensitiveDict(view=VIEW)
 HIERARCHY = CaseInsensitiveDict(