rainbow-rb-flat-buffers 0.0.9.dev5__tar.gz

rainbow_rb_flat_buffers-0.0.9.dev5/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: rainbow-rb-flat-buffers
+Version: 0.0.9.dev5
+Summary: Rainbow FlatBuffers Conveted to Python
+Author-email: Derek <dfd1123@rainbow-robotics.com>
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: flatbuffers<26.0.0,>=25.2.10
+Requires-Dist: numpy>=2.3.3
+
+# rb_flat_buffers
+
+`rb_flat_buffers`는 `schemas/*.fbs`로부터 생성된 Python FlatBuffer 코드 패키지입니다.
+
+## 핵심 요약
+
+- 소스 스키마: `/schemas/**/*.fbs`
+- 생성 결과 1: `backend/packages/rb_flat_buffers/src/rb_flat_buffers/**` (FlatBuffer Python generated code)
+- 생성 결과 2: `backend/packages/rb_schemas/src/rb_schemas/fbs_models/**` (Pydantic 모델)
+
+즉, `make backend.flatc`를 실행하면:
+1. FlatBuffer Python 코드가 `rb_flat_buffers`에 생성되고
+2. 동일 스키마 기반 Pydantic 모델이 `rb_schemas`에 생성됩니다.
+
+## 생성 방법
+
+프로젝트 루트에서:
+
+```bash
+make backend.flatc
+```
+
+`backend.mk`의 `backend.flatc` 타깃은 내부적으로 아래를 순서대로 실행합니다.
+
+1) `scripts/backend/generate_flatbuffers.py`
+- `flatc --python --gen-object-api --gen-all` 기반 생성
+- 출력: `backend/packages/rb_flat_buffers/src/rb_flat_buffers`
+
+2) `backend/packages/rb_flat_buffers/scripts/patch_imports.py`
+- generated import 경로/누락 import 보정
+
+3) `scripts/backend/fbs_to_pydantic.py`
+- `.fbs`를 Pydantic 모델로 변환
+- 출력: `backend/packages/rb_schemas/src/rb_schemas/fbs_models`
+
+## 언제 실행해야 하나
+
+아래 케이스에서는 `make backend.flatc`를 다시 실행해야 합니다.
+
+- `schemas/*.fbs` 수정
+- 신규 `.fbs` 파일 추가/삭제
+- FlatBuffer 타입/필드 변경(table/struct/enum/union)
+
+## rb_flat_buffers 사용 예시
+
+예: 요청 객체 전송 + **값이 채워진 FlatBuffer 응답(`returnValue`)** 수신
+
+```python
+# server/queryable 쪽
+from rb_flat_buffers.IPC.Request_Move_SmoothJogStop import Request_Move_SmoothJogStopT
+from rb_flat_buffers.IPC.Response_Functions import Response_FunctionsT
+from rb_zenoh.router import ZenohRouter
+
+router = ZenohRouter()
+
+@router.queryable(
+    "C500920/call_smoothjog_stop",
+    flatbuffer_req_t=Request_Move_SmoothJogStopT,
+    flatbuffer_res_buf_size=64,
+)
+def on_call_pause(req, params=None):
+    print(req.stoptime)  # 요청으로 전달된 값 사용 가능
+    res = Response_FunctionsT()
+    res.returnValue = 123  # 빈 payload가 아니라 실제 값 포함
+    return res
+```
+
+```python
+# client/query 쪽
+from rb_flat_buffers.IPC.Request_Move_SmoothJogStop import Request_Move_SmoothJogStopT
+from rb_flat_buffers.IPC.Response_Functions import Response_FunctionsT
+from rb_zenoh.client import ZenohClient
+
+client = ZenohClient()
+req = Request_Move_SmoothJogStopT()
+req.stoptime = 0.7
+
+res = client.query_one(
+    "C500920/call_smoothjog_stop",
+    flatbuffer_req_obj=req,
+    flatbuffer_res_T_class=Response_FunctionsT,
+    flatbuffer_buf_size=64,
+)
+
+obj = res.get("obj_payload")
+print(obj.returnValue)  # 123
+```
+
+## rb_schemas(Pydantic) 사용 예시
+
+`query_one` 응답의 `obj_payload`를 Pydantic으로 validate한 뒤, `model_dump`에서 원하는 key case를 선택할 수 있습니다.
+
+```python
+from rb_flat_buffers.IPC.Response_Functions import Response_FunctionsT
+from rb_schemas.fbs_models.nexus.v1.deploy_models import Response_Deploy_UploadPD
+from rb_utils.parser import t_to_dict
+from rb_zenoh.client import ZenohClient
+
+client = ZenohClient()
+
+res = client.query_one(
+    "deploy/call_upload",
+    flatbuffer_res_T_class=Response_FunctionsT,
+    timeout=0.3,
+)
+
+obj_payload = res.get("obj_payload")
+
+# 1) FlatBuffer T 객체 -> dict 변환
+raw_dict = t_to_dict(obj_payload) if obj_payload is not None else {}
+
+# 2) Pydantic validate
+pd_obj = Response_Deploy_UploadPD.model_validate(raw_dict)
+
+# 3) key case 선택
+snake_case = pd_obj.model_dump(by_alias=False)  # ex) return_value
+camel_case = pd_obj.model_dump(by_alias=True)   # ex) returnValue
+```
+
+## 주의사항
+
+- 패키지명은 `rb_flat_buffers`입니다. (`rb_flat_buffer` 아님)
+- generated 파일은 수동 수정하지 않는 것을 권장합니다.
+- `flatc`가 PATH에 없으면 `make backend.flatc`가 실패합니다.

rainbow_rb_flat_buffers-0.0.9.dev5/README.md

@@ -0,0 +1,124 @@
+# rb_flat_buffers
+
+`rb_flat_buffers`는 `schemas/*.fbs`로부터 생성된 Python FlatBuffer 코드 패키지입니다.
+
+## 핵심 요약
+
+- 소스 스키마: `/schemas/**/*.fbs`
+- 생성 결과 1: `backend/packages/rb_flat_buffers/src/rb_flat_buffers/**` (FlatBuffer Python generated code)
+- 생성 결과 2: `backend/packages/rb_schemas/src/rb_schemas/fbs_models/**` (Pydantic 모델)
+
+즉, `make backend.flatc`를 실행하면:
+1. FlatBuffer Python 코드가 `rb_flat_buffers`에 생성되고
+2. 동일 스키마 기반 Pydantic 모델이 `rb_schemas`에 생성됩니다.
+
+## 생성 방법
+
+프로젝트 루트에서:
+
+```bash
+make backend.flatc
+```
+
+`backend.mk`의 `backend.flatc` 타깃은 내부적으로 아래를 순서대로 실행합니다.
+
+1) `scripts/backend/generate_flatbuffers.py`
+- `flatc --python --gen-object-api --gen-all` 기반 생성
+- 출력: `backend/packages/rb_flat_buffers/src/rb_flat_buffers`
+
+2) `backend/packages/rb_flat_buffers/scripts/patch_imports.py`
+- generated import 경로/누락 import 보정
+
+3) `scripts/backend/fbs_to_pydantic.py`
+- `.fbs`를 Pydantic 모델로 변환
+- 출력: `backend/packages/rb_schemas/src/rb_schemas/fbs_models`
+
+## 언제 실행해야 하나
+
+아래 케이스에서는 `make backend.flatc`를 다시 실행해야 합니다.
+
+- `schemas/*.fbs` 수정
+- 신규 `.fbs` 파일 추가/삭제
+- FlatBuffer 타입/필드 변경(table/struct/enum/union)
+
+## rb_flat_buffers 사용 예시
+
+예: 요청 객체 전송 + **값이 채워진 FlatBuffer 응답(`returnValue`)** 수신
+
+```python
+# server/queryable 쪽
+from rb_flat_buffers.IPC.Request_Move_SmoothJogStop import Request_Move_SmoothJogStopT
+from rb_flat_buffers.IPC.Response_Functions import Response_FunctionsT
+from rb_zenoh.router import ZenohRouter
+
+router = ZenohRouter()
+
+@router.queryable(
+    "C500920/call_smoothjog_stop",
+    flatbuffer_req_t=Request_Move_SmoothJogStopT,
+    flatbuffer_res_buf_size=64,
+)
+def on_call_pause(req, params=None):
+    print(req.stoptime)  # 요청으로 전달된 값 사용 가능
+    res = Response_FunctionsT()
+    res.returnValue = 123  # 빈 payload가 아니라 실제 값 포함
+    return res
+```
+
+```python
+# client/query 쪽
+from rb_flat_buffers.IPC.Request_Move_SmoothJogStop import Request_Move_SmoothJogStopT
+from rb_flat_buffers.IPC.Response_Functions import Response_FunctionsT
+from rb_zenoh.client import ZenohClient
+
+client = ZenohClient()
+req = Request_Move_SmoothJogStopT()
+req.stoptime = 0.7
+
+res = client.query_one(
+    "C500920/call_smoothjog_stop",
+    flatbuffer_req_obj=req,
+    flatbuffer_res_T_class=Response_FunctionsT,
+    flatbuffer_buf_size=64,
+)
+
+obj = res.get("obj_payload")
+print(obj.returnValue)  # 123
+```
+
+## rb_schemas(Pydantic) 사용 예시
+
+`query_one` 응답의 `obj_payload`를 Pydantic으로 validate한 뒤, `model_dump`에서 원하는 key case를 선택할 수 있습니다.
+
+```python
+from rb_flat_buffers.IPC.Response_Functions import Response_FunctionsT
+from rb_schemas.fbs_models.nexus.v1.deploy_models import Response_Deploy_UploadPD
+from rb_utils.parser import t_to_dict
+from rb_zenoh.client import ZenohClient
+
+client = ZenohClient()
+
+res = client.query_one(
+    "deploy/call_upload",
+    flatbuffer_res_T_class=Response_FunctionsT,
+    timeout=0.3,
+)
+
+obj_payload = res.get("obj_payload")
+
+# 1) FlatBuffer T 객체 -> dict 변환
+raw_dict = t_to_dict(obj_payload) if obj_payload is not None else {}
+
+# 2) Pydantic validate
+pd_obj = Response_Deploy_UploadPD.model_validate(raw_dict)
+
+# 3) key case 선택
+snake_case = pd_obj.model_dump(by_alias=False)  # ex) return_value
+camel_case = pd_obj.model_dump(by_alias=True)   # ex) returnValue
+```
+
+## 주의사항
+
+- 패키지명은 `rb_flat_buffers`입니다. (`rb_flat_buffer` 아님)
+- generated 파일은 수동 수정하지 않는 것을 권장합니다.
+- `flatc`가 PATH에 없으면 `make backend.flatc`가 실패합니다.

rainbow_rb_flat_buffers-0.0.9.dev5/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rainbow-rb-flat-buffers"
+version = "0.0.9.dev5"
+requires-python = ">=3.12,<3.13"
+description = "Rainbow FlatBuffers Conveted to Python"
+authors = [
+    { name = "Derek", email = "dfd1123@rainbow-robotics.com" },
+]
+readme = "README.md"
+
+dependencies = [
+    "flatbuffers>=25.2.10,<26.0.0",
+    "numpy>=2.3.3",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["rainbow.rb_flat_buffers*"]
+
+[tool.setuptools.package-data]
+"*" = ["py.typed"]

rainbow_rb_flat_buffers-0.0.9.dev5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rainbow_rb_flat_buffers-0.0.9.dev5/src/rainbow/rb_flat_buffers/IPC/EmailMessage.py

@@ -0,0 +1,216 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: IPC
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+from typing import Any
+from rainbow.rb_flat_buffers.IPC.FileMessage import FileMessage, FileMessageT
+from typing import Optional
+np = import_numpy()
+
+class EmailMessage(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset: int = 0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = EmailMessage()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEmailMessage(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # EmailMessage
+    def Init(self, buf: bytes, pos: int):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # EmailMessage
+    def FromEmail(self) -> Optional[str]:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # EmailMessage
+    def ToEmail(self) -> Optional[str]:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # EmailMessage
+    def Subject(self) -> Optional[str]:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # EmailMessage
+    def Body(self) -> Optional[str]:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # EmailMessage
+    def Attachment(self, j: int) -> Optional[FileMessage]:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = FileMessage()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # EmailMessage
+    def AttachmentLength(self) -> int:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EmailMessage
+    def AttachmentIsNone(self) -> bool:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def EmailMessageStart(builder: flatbuffers.Builder):
+    builder.StartObject(5)
+
+def Start(builder: flatbuffers.Builder):
+    EmailMessageStart(builder)
+
+def EmailMessageAddFromEmail(builder: flatbuffers.Builder, fromEmail: int):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fromEmail), 0)
+
+def AddFromEmail(builder: flatbuffers.Builder, fromEmail: int):
+    EmailMessageAddFromEmail(builder, fromEmail)
+
+def EmailMessageAddToEmail(builder: flatbuffers.Builder, toEmail: int):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(toEmail), 0)
+
+def AddToEmail(builder: flatbuffers.Builder, toEmail: int):
+    EmailMessageAddToEmail(builder, toEmail)
+
+def EmailMessageAddSubject(builder: flatbuffers.Builder, subject: int):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subject), 0)
+
+def AddSubject(builder: flatbuffers.Builder, subject: int):
+    EmailMessageAddSubject(builder, subject)
+
+def EmailMessageAddBody(builder: flatbuffers.Builder, body: int):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(body), 0)
+
+def AddBody(builder: flatbuffers.Builder, body: int):
+    EmailMessageAddBody(builder, body)
+
+def EmailMessageAddAttachment(builder: flatbuffers.Builder, attachment: int):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attachment), 0)
+
+def AddAttachment(builder: flatbuffers.Builder, attachment: int):
+    EmailMessageAddAttachment(builder, attachment)
+
+def EmailMessageStartAttachmentVector(builder, numElems: int) -> int:
+    return builder.StartVector(4, numElems, 4)
+
+def StartAttachmentVector(builder, numElems: int) -> int:
+    return EmailMessageStartAttachmentVector(builder, numElems)
+
+def EmailMessageEnd(builder: flatbuffers.Builder) -> int:
+    return builder.EndObject()
+
+def End(builder: flatbuffers.Builder) -> int:
+    return EmailMessageEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class EmailMessageT(object):
+
+    # EmailMessageT
+    def __init__(
+        self,
+        fromEmail = None,
+        toEmail = None,
+        subject = None,
+        body = None,
+        attachment = None,
+    ):
+        self.fromEmail = fromEmail  # type: Optional[str]
+        self.toEmail = toEmail  # type: Optional[str]
+        self.subject = subject  # type: Optional[str]
+        self.body = body  # type: Optional[str]
+        self.attachment = attachment  # type: Optional[List[FileMessageT]]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        emailMessage = EmailMessage()
+        emailMessage.Init(buf, pos)
+        return cls.InitFromObj(emailMessage)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, emailMessage):
+        x = EmailMessageT()
+        x._UnPack(emailMessage)
+        return x
+
+    # EmailMessageT
+    def _UnPack(self, emailMessage):
+        if emailMessage is None:
+            return
+        self.fromEmail = emailMessage.FromEmail()
+        self.toEmail = emailMessage.ToEmail()
+        self.subject = emailMessage.Subject()
+        self.body = emailMessage.Body()
+        if not emailMessage.AttachmentIsNone():
+            self.attachment = []
+            for i in range(emailMessage.AttachmentLength()):
+                if emailMessage.Attachment(i) is None:
+                    self.attachment.append(None)
+                else:
+                    fileMessage_ = FileMessageT.InitFromObj(emailMessage.Attachment(i))
+                    self.attachment.append(fileMessage_)
+
+    # EmailMessageT
+    def Pack(self, builder):
+        if self.fromEmail is not None:
+            fromEmail = builder.CreateString(self.fromEmail)
+        if self.toEmail is not None:
+            toEmail = builder.CreateString(self.toEmail)
+        if self.subject is not None:
+            subject = builder.CreateString(self.subject)
+        if self.body is not None:
+            body = builder.CreateString(self.body)
+        if self.attachment is not None:
+            attachmentlist = []
+            for i in range(len(self.attachment)):
+                attachmentlist.append(self.attachment[i].Pack(builder))
+            EmailMessageStartAttachmentVector(builder, len(self.attachment))
+            for i in reversed(range(len(self.attachment))):
+                builder.PrependUOffsetTRelative(attachmentlist[i])
+            attachment = builder.EndVector()
+        EmailMessageStart(builder)
+        if self.fromEmail is not None:
+            EmailMessageAddFromEmail(builder, fromEmail)
+        if self.toEmail is not None:
+            EmailMessageAddToEmail(builder, toEmail)
+        if self.subject is not None:
+            EmailMessageAddSubject(builder, subject)
+        if self.body is not None:
+            EmailMessageAddBody(builder, body)
+        if self.attachment is not None:
+            EmailMessageAddAttachment(builder, attachment)
+        emailMessage = EmailMessageEnd(builder)
+        return emailMessage

rainbow_rb_flat_buffers-0.0.9.dev5/src/rainbow/rb_flat_buffers/IPC/EmailMessage.pyi

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import flatbuffers
+import numpy as np
+
+import typing
+from rb_flat_buffers.IPC.FileMessage import FileMessage, FileMessageT
+
+uoffset: typing.TypeAlias = flatbuffers.number_types.UOffsetTFlags.py_type
+
+class EmailMessage(object):
+  @classmethod
+  def GetRootAs(cls, buf: bytes, offset: int) -> EmailMessage: ...
+  @classmethod
+  def GetRootAsEmailMessage(cls, buf: bytes, offset: int) -> EmailMessage: ...
+  def Init(self, buf: bytes, pos: int) -> None: ...
+  def FromEmail(self) -> str | None: ...
+  def ToEmail(self) -> str | None: ...
+  def Subject(self) -> str | None: ...
+  def Body(self) -> str | None: ...
+  def Attachment(self, i: int) -> FileMessage | None: ...
+  def AttachmentLength(self) -> int: ...
+  def AttachmentIsNone(self) -> bool: ...
+class EmailMessageT(object):
+  fromEmail: str | None
+  toEmail: str | None
+  subject: str | None
+  body: str | None
+  attachment: typing.List[FileMessageT]
+  def __init__(
+    self,
+    fromEmail: str | None = ...,
+    toEmail: str | None = ...,
+    subject: str | None = ...,
+    body: str | None = ...,
+    attachment: typing.List['FileMessageT'] | None = ...,
+  ) -> None: ...
+  @classmethod
+  def InitFromBuf(cls, buf: bytes, pos: int) -> EmailMessageT: ...
+  @classmethod
+  def InitFromPackedBuf(cls, buf: bytes, pos: int = 0) -> EmailMessageT: ...
+  @classmethod
+  def InitFromObj(cls, emailMessage: EmailMessage) -> EmailMessageT: ...
+  def _UnPack(self, emailMessage: EmailMessage) -> None: ...
+  def Pack(self, builder: flatbuffers.Builder) -> None: ...
+def EmailMessageStart(builder: flatbuffers.Builder) -> None: ...
+def Start(builder: flatbuffers.Builder) -> None: ...
+def EmailMessageAddFromEmail(builder: flatbuffers.Builder, fromEmail: uoffset) -> None: ...
+def EmailMessageAddToEmail(builder: flatbuffers.Builder, toEmail: uoffset) -> None: ...
+def EmailMessageAddSubject(builder: flatbuffers.Builder, subject: uoffset) -> None: ...
+def EmailMessageAddBody(builder: flatbuffers.Builder, body: uoffset) -> None: ...
+def EmailMessageAddAttachment(builder: flatbuffers.Builder, attachment: uoffset) -> None: ...
+def EmailMessageStartAttachmentVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
+def StartAttachmentVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
+def EmailMessageEnd(builder: flatbuffers.Builder) -> uoffset: ...
+def End(builder: flatbuffers.Builder) -> uoffset: ...
+

rainbow_rb_flat_buffers-0.0.9.dev5/src/rainbow/rb_flat_buffers/IPC/FileAck.py

@@ -0,0 +1,129 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: IPC
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+from typing import Any
+from typing import Optional
+np = import_numpy()
+
+class FileAck(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset: int = 0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = FileAck()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsFileAck(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # FileAck
+    def Init(self, buf: bytes, pos: int):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # FileAck
+    def Session(self) -> Optional[str]:
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # FileAck
+    def Index(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # FileAck
+    def Ok(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def FileAckStart(builder: flatbuffers.Builder):
+    builder.StartObject(3)
+
+def Start(builder: flatbuffers.Builder):
+    FileAckStart(builder)
+
+def FileAckAddSession(builder: flatbuffers.Builder, session: int):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(session), 0)
+
+def AddSession(builder: flatbuffers.Builder, session: int):
+    FileAckAddSession(builder, session)
+
+def FileAckAddIndex(builder: flatbuffers.Builder, index: int):
+    builder.PrependUint32Slot(1, index, 0)
+
+def AddIndex(builder: flatbuffers.Builder, index: int):
+    FileAckAddIndex(builder, index)
+
+def FileAckAddOk(builder: flatbuffers.Builder, ok: bool):
+    builder.PrependBoolSlot(2, ok, 0)
+
+def AddOk(builder: flatbuffers.Builder, ok: bool):
+    FileAckAddOk(builder, ok)
+
+def FileAckEnd(builder: flatbuffers.Builder) -> int:
+    return builder.EndObject()
+
+def End(builder: flatbuffers.Builder) -> int:
+    return FileAckEnd(builder)
+
+
+class FileAckT(object):
+
+    # FileAckT
+    def __init__(
+        self,
+        session = None,
+        index = 0,
+        ok = False,
+    ):
+        self.session = session  # type: Optional[str]
+        self.index = index  # type: int
+        self.ok = ok  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        fileAck = FileAck()
+        fileAck.Init(buf, pos)
+        return cls.InitFromObj(fileAck)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, fileAck):
+        x = FileAckT()
+        x._UnPack(fileAck)
+        return x
+
+    # FileAckT
+    def _UnPack(self, fileAck):
+        if fileAck is None:
+            return
+        self.session = fileAck.Session()
+        self.index = fileAck.Index()
+        self.ok = fileAck.Ok()
+
+    # FileAckT
+    def Pack(self, builder):
+        if self.session is not None:
+            session = builder.CreateString(self.session)
+        FileAckStart(builder)
+        if self.session is not None:
+            FileAckAddSession(builder, session)
+        FileAckAddIndex(builder, self.index)
+        FileAckAddOk(builder, self.ok)
+        fileAck = FileAckEnd(builder)
+        return fileAck