Kralot/sdk-notion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Finaliza ajustes para iniciar Repositorio Git do SDK de Integração do Notion separado do meu projeto original

Browse Source 
---

- Cria singleton de `client` com func `configure` para inicializar e `get_instance` para buscar instância do client;
- Ajusta clients para buscar headers vindo do pai `client` e fixa versão legacy no client de databases;
- Adiciona inicialização de `client` no init do projeto com api_token e api_version informados pelo usuário;
- Altera `NotionConfig` para inserir `database_id` no lugar de `database_name`;
- Altera sistema para receber `database_id` no lugar de `database_name`;
- Altera tipo de `properties` em `schemas.responses.pages.Page` de `Union[Dict[str, Any]], TDB` para `Union[Any, TDB]` para resolver reclamações de type hint;
- Adiciona param `generic_response` no init de `client` e nos clients e databases e pages para pular uso de mapping ao usar `.generic`;
- Adiciona param `raw_response` para pular parser e mappings e retornar resposta original da api;
- Finaliza `types` com subpastas para importações mas com init mãe vazio para evitar dependência circular e permitir uso de `notion.types.` pelo usuário;
- Remove importações do projeto original não relacionadas com o SDK;
- Adiciona param `timezone` na func `start_date` em `orm.common.SetProperty` que antes vinha do env, para posteriormente puxar da init da integração;
- Monta `LICENSE`, `README.md` e `pyproject.toml` base simples para commit inicial do projeto permitindo build de pacote;

---
This commit is contained in:
Eduardo Riguetto
2026-01-20 22:26:39 -03:00
commit aff0446458
72 changed files with 2910 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
notion/orm/repositories/databases/CreateDatabasePage.py
Executable
+93
View File
@@ -0,0 +1,93 @@
from typing import Optional, Literal, Generic, TypeVar
from pydantic import validate_call
from ....schemas.responses import Schemas as _schm
from ...mapping.database import NotionDatabase as _NotionDatabase
from ...mapping import Mapping as _map
from ...parsers import Parser as _parser
from ...common.SetProperty import SetProperty as _setProperty
from ..pages.CreatePage import CreatePage as _CreatePage
TDB = TypeVar('TDB', bound = _NotionDatabase)
class CreateDatabasePage(Generic[TDB]):
def __init__(self,
database_id : str,
generic_response : bool = False
) -> None:
self._database_id = database_id
self._generic_response = generic_response
self._instance = _CreatePage().set_parent(
type = "database_id",
parent_id = self._database_id
)
self.set_property = _setProperty(self, self._instance.data["properties"])
@validate_call
def set_template(self,
type : Literal["default", "template_id"],
template_id : Optional[str] = None
):
self._instance.set_template(
type = type,
template_id = template_id
)
return self
@validate_call
def set_title(self,
prop_name : Optional[str],
prop_value : Optional[str]
):
self._instance.set_title(
prop_name = prop_name,
prop_value = prop_value
)
return self
@validate_call
def set_icon(self,
type : Literal["external"],
content : Optional[str] = None
):
self._instance.set_icon(
type = type,
content = content
)
return self
@validate_call
async def call(self,
map_properties : bool = True,
raw_response : bool = False
) -> _schm.pages.Page[TDB]:
page = await self._instance.call(
parse_properties = False
)
if not raw_response:
if map_properties:
parser = None
if not self._generic_response:
# Tenta pegar parser do registry
parser = _map.registry.get_parser(
database_id = self._database_id,
page_parser = _parser.page_props
)
# Fallback: se database não registrada, usa parser genérico
if not parser:
parser = _parser.page_props
page = page.model_dump()
mapped_properties = parser(page = page)
page["properties"] = mapped_properties
page = _schm.pages.Page(**page)
return page
__all__ = ["CreateDatabasePage"]
notion/orm/repositories/databases/SearchPage.py
Executable
+101
View File
@@ -0,0 +1,101 @@
from typing import Optional, Generic, TypeVar
from pydantic import validate_call
from ....client import get_client as _get_client
from ....schemas.responses import Schemas as _schm
from ...mapping.database import NotionDatabase as _NotionDatabase
from ...mapping import Mapping as _map
from ...common.QueryFilter import QueryFilter as _Filter, _NotionFilter
from ...common.QuerySort import QuerySort as _Sort, _NotionSort
from ...parsers import Parser as _parser
TDB = TypeVar('TDB', bound = _NotionDatabase)
class SearchPage(Generic[TDB]):
def __init__(self,
database_id : str,
generic_response : bool = False
) -> None:
self._database_id = database_id
self._generic_response = generic_response
self.query_limit : int = 100
self.filter = _Filter
self._filter_obj : Optional[_NotionFilter] = None
self.sort = _Sort
self._sort_obj : Optional[_NotionSort] = None
def set_limit(self,
page_limit : int
):
"Define o limite de páginas a serem retornadas na requisição"
self.query_limit = page_limit
return self
def set_sort(self,
sort_obj : _NotionSort
):
"Define a classificação a ser usada na query"
self._sort_obj = sort_obj
return self
def set_filter(self,
filter_obj : _NotionFilter
):
"Define o filtro a ser usado na query"
self._filter_obj = filter_obj
return self
@validate_call
async def call(self,
map_properties : bool = True,
raw_response : bool = False
) -> _schm.databases.Query[TDB]:
payload = {}
if self.query_limit:
payload["page_size"] = self.query_limit
if self._sort_obj:
payload["sorts"] = self._sort_obj.to_dict()
if self._filter_obj:
payload["filter"] = self._filter_obj.to_dict()
client = _get_client()
query = await client.databases.query(
database_id = self._database_id,
json_data = payload
)
if query['object'] == 'error':
error = _schm.errors.Error(**query)
raise KeyError(error.__dict__)
pages = []
results = query["results"]
if not raw_response:
if map_properties:
parser = None
if not self._generic_response:
# Tenta pegar parser do registry
parser = _map.registry.get_parser(
database_id = self._database_id,
page_parser = _parser.page_props
)
# Fallback: se database não registrada, usa parser genérico
if not parser:
parser = _parser.page_props
for page in results:
page_properties = parser(page)
page["properties"] = page_properties if page_properties else None
pages.append(page)
results = pages
return _schm.databases.Query(**query)
__all__ = ["SearchPage"]
notion/orm/repositories/databases/SearchPageProperty.py
Executable
+94
View File
@@ -0,0 +1,94 @@
from typing import Optional, Literal, List
from ....client import get_client as _get_client
from ....schemas.orm.database import Schemas as _schm
from ....schemas.responses import Schemas as _schmResponses
from ...common.QueryFilter import QueryFilter as _Filter, _NotionFilter
from ...parsers import Parser as _parser
class SearchPageProperty:
"""
# CUIDADO AO UTILIZAR!!
### [Bug Conhecido](https://community.latenode.com/t/notion-api-relation-property-showing-empty-array-despite-ui-showing-connected-pages/25780) na API do Notion impede retornos confiáveis em propriedades paginadas
Ultimo teste : 2026-01-10
"""
def __init__(self, database_id : str) -> None:
self._database_id = database_id
self.filter = _Filter
self._filter_obj : Optional[_NotionFilter] = None
self._property_type = None
def set_filter(self,
property_type : Literal[
"unique_id",
"icon",
"title",
"number",
"checkbox",
"start_date",
"end_date",
#"relation",
"text",
"rich_text",
"select",
"multi_select",
"status",
"media",
"url",
"email",
"phone",
"person",
"place"
],
filter_obj : _NotionFilter
):
"Define o filtro a ser usado na query"
self._property_type = property_type
self._filter_obj = filter_obj
return self
async def call(self,
raw_response : bool = False
) -> List[_schm.SearchPageProperty]:
if not self._property_type:
raise TypeError("Filter is not fully defined")
payload = {}
if self._filter_obj:
payload["filter"] = self._filter_obj.to_dict()
client = _get_client()
query = await client.databases.query_propriety(
database_id = self._database_id,
propriety_type = self._property_type,
json_data = payload
)
if query['object'] == 'error':
error = _schmResponses.errors.Error(**query)
raise KeyError(error.__dict__)
results = query["results"]
pages = []
for page in results:
if raw_response:
page["properties"] = _parser.page_props(page = page)
pages.append(page)
result = []
for page in pages:
prop_value = page["properties"]
if prop_value:
prop_value = list(prop_value.values())[0]
result.append(
_schm.SearchPageProperty(
page_id = page["id"],
prop_value = prop_value
)
)
return result
notion/orm/repositories/databases/__init__.py
Executable
+57
View File
@@ -0,0 +1,57 @@
from typing import Generic, TypeVar
from ...mapping.database import NotionDatabase as _NotionDatabase
from ..pages import _Pages as _Pages
from .CreateDatabasePage import CreateDatabasePage as _CreateDatabasePage
from .SearchPage import SearchPage as _SearchPage
from .SearchPageProperty import SearchPageProperty as _SearchPageProperty
TDB = TypeVar('TDB', bound = _NotionDatabase)
class Database(Generic[TDB]):
def __init__(self,
database_id : str,
generic_response : bool = False
) -> None:
self._database_id = database_id
self._generic_response = generic_response
@property
def CreateDatabasePage(self) -> _CreateDatabasePage[TDB]:
return _CreateDatabasePage(
database_id = self._database_id,
generic_response = self._generic_response
)
@property
def SearchPage(self) -> _SearchPage[TDB]:
return _SearchPage(
database_id = self._database_id,
generic_response = self._generic_response
)
@property
def SearchPageProperty(self) -> _SearchPageProperty:
return _SearchPageProperty(
database_id = self._database_id
)
@property
def page(self) -> _Pages[TDB]:
return _Pages(
database_id = self._database_id,
generic_response = self._generic_response
)
@staticmethod
def generic(database_id : str) -> 'Database[_NotionDatabase]':
"Acessa database sem schema definido"
return Database(
database_id = database_id,
generic_response = True
)
__all__ = ["Database"]