cime.py 1.0.0__tar.gz

cime_py-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chocolily (medeia_beliar@naver.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cime_py-1.0.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: cime.py
+Version: 1.0.0
+Summary: Unofficial Python SDK for CI.ME OpenAPI
+Author-email: chocolily <medeia_beliar@naver.com>
+Project-URL: Homepage, https://github.com/choco-lily/cime.py
+Project-URL: Bug Tracker, https://github.com/choco-lily/cime.py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Requires-Dist: websockets
+Requires-Dist: pydantic
+Dynamic: license-file
+
+# cime.py
+
+CI.ME 공식 API를 활용한 비공식 Python SDK입니다.
+(Unofficial Python SDK using Official CI.ME OpenAPI)
+
+## Installation
+
+```bash
+pip install cime.py
+```
+
+## Quick Start
+
+### Async Client Initialization
+
+```python
+import asyncio
+from cime import CimeClient
+
+async def main():
+    async with CimeClient(
+        client_id='YOUR_CLIENT_ID',
+        client_secret='YOUR_CLIENT_SECRET'
+    ) as client:
+        # Use bearer token for user-specific actions
+        # client.bearer_token = 'YOUR_BEARER_TOKEN'
+        
+        me = await client.get_me()
+        print(f"My Channel: {me.content.channelName}")
+
+asyncio.run(main())
+```
+
+### WebSocket Events
+
+```python
+import asyncio
+from cime import CimeEvents, CimeClient
+
+async def on_chat(data):
+    print(f"New Chat: {data['message']}")
+
+async def main():
+    async with CimeClient(client_id='...', client_secret='...') as client:
+        session = await client.create_session()
+        events = CimeEvents(session.content.url)
+        
+        events.on("CHAT", on_chat)
+        await events.subscribe("CHAT")
+        
+        await events.connect()
+
+asyncio.run(main())
+```
+
+## Features
+
+- CI.ME REST API (User, Channel, Live, Chat, etc.) 완벽 지원
+- `httpx` 및 `websockets` 기반의 고성능 비동기 설계
+- Pydantic 모델을 통한 강력한 데이터 검증 및 타입 힌트 제공
+
+## License
+
+MIT

cime_py-1.0.0/README.md

@@ -0,0 +1,64 @@
+# cime.py
+
+CI.ME 공식 API를 활용한 비공식 Python SDK입니다.
+(Unofficial Python SDK using Official CI.ME OpenAPI)
+
+## Installation
+
+```bash
+pip install cime.py
+```
+
+## Quick Start
+
+### Async Client Initialization
+
+```python
+import asyncio
+from cime import CimeClient
+
+async def main():
+    async with CimeClient(
+        client_id='YOUR_CLIENT_ID',
+        client_secret='YOUR_CLIENT_SECRET'
+    ) as client:
+        # Use bearer token for user-specific actions
+        # client.bearer_token = 'YOUR_BEARER_TOKEN'
+        
+        me = await client.get_me()
+        print(f"My Channel: {me.content.channelName}")
+
+asyncio.run(main())
+```
+
+### WebSocket Events
+
+```python
+import asyncio
+from cime import CimeEvents, CimeClient
+
+async def on_chat(data):
+    print(f"New Chat: {data['message']}")
+
+async def main():
+    async with CimeClient(client_id='...', client_secret='...') as client:
+        session = await client.create_session()
+        events = CimeEvents(session.content.url)
+        
+        events.on("CHAT", on_chat)
+        await events.subscribe("CHAT")
+        
+        await events.connect()
+
+asyncio.run(main())
+```
+
+## Features
+
+- CI.ME REST API (User, Channel, Live, Chat, etc.) 완벽 지원
+- `httpx` 및 `websockets` 기반의 고성능 비동기 설계
+- Pydantic 모델을 통한 강력한 데이터 검증 및 타입 힌트 제공
+
+## License
+
+MIT

cime_py-1.0.0/cime/__init__.py

@@ -0,0 +1,3 @@
+from .client import CimeClient
+from .events import CimeEvents
+from .models import *

cime_py-1.0.0/cime/client.py

@@ -0,0 +1,118 @@
+import httpx
+from typing import Optional, List, Dict, Any, Union
+from .models import (
+    AuthConfig, 
+    CimeResponse, 
+    UserChannelInfo, 
+    BulkChannelResponse, 
+    LiveListResponse, 
+    LiveSetting, 
+    ChatSettings, 
+    MessageResponse, 
+    CategorySearchResponse, 
+    SessionResponse
+)
+
+class CimeClient:
+    def __init__(
+        self, 
+        client_id: Optional[str] = None, 
+        client_secret: Optional[str] = None, 
+        bearer_token: Optional[str] = None, 
+        base_url: str = 'https://openapi.ci.me'
+    ):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.bearer_token = bearer_token
+        self.base_url = base_url
+        self.client = httpx.AsyncClient(base_url=base_url)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client.aclose()
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {}
+        if self.bearer_token:
+            headers['Authorization'] = f'Bearer {self.bearer_token}'
+        elif self.client_id and self.client_secret:
+            headers['Client-Id'] = self.client_id
+            headers['Client-Secret'] = self.client_secret
+        return headers
+
+    async def get_me(self) -> CimeResponse[UserChannelInfo]:
+        resp = await self.client.get('/api/openapi/open/v1/users/me', headers=self._get_headers())
+        return CimeResponse[UserChannelInfo](**resp.json())
+
+    async def get_channels(self, channel_ids: List[str]) -> CimeResponse[BulkChannelResponse]:
+        params = {'channelIds': ','.join(channel_ids)}
+        resp = await self.client.get('/api/openapi/open/v1/channels', params=params, headers=self._get_headers())
+        return CimeResponse[BulkChannelResponse](**resp.json())
+
+    async def get_followers(self) -> CimeResponse[Any]:
+        resp = await self.client.get('/api/openapi/open/v1/channels/followers', headers=self._get_headers())
+        return CimeResponse[Any](**resp.json())
+
+    async def get_subscribers(self) -> CimeResponse[Any]:
+        resp = await self.client.get('/api/openapi/open/v1/channels/subscribers', headers=self._get_headers())
+        return CimeResponse[Any](**resp.json())
+
+    async def get_lives(
+        self, 
+        channel_ids: Optional[List[str]] = None, 
+        page: Optional[int] = None, 
+        size: Optional[int] = None
+    ) -> CimeResponse[LiveListResponse]:
+        params = {}
+        if channel_ids: params['channelIds'] = ','.join(channel_ids)
+        if page is not None: params['page'] = page
+        if size is not None: params['size'] = size
+        
+        resp = await self.client.get('/api/openapi/open/v1/lives', params=params, headers=self._get_headers())
+        return CimeResponse[LiveListResponse](**resp.json())
+
+    async def get_live_setting(self) -> CimeResponse[LiveSetting]:
+        resp = await self.client.get('/api/openapi/open/v1/lives/setting', headers=self._get_headers())
+        return CimeResponse[LiveSetting](**resp.json())
+
+    async def update_live_setting(self, settings: Dict[str, Any]) -> CimeResponse[LiveSetting]:
+        resp = await self.client.patch('/api/openapi/open/v1/lives/setting', json=settings, headers=self._get_headers())
+        return CimeResponse[LiveSetting](**resp.json())
+
+    async def get_chat_settings(self) -> CimeResponse[ChatSettings]:
+        resp = await self.client.get('/api/openapi/open/v1/chats/settings', headers=self._get_headers())
+        return CimeResponse[ChatSettings](**resp.json())
+
+    async def update_chat_settings(self, settings: Dict[str, Any]) -> CimeResponse[ChatSettings]:
+        resp = await self.client.put('/api/openapi/open/v1/chats/settings', json=settings, headers=self._get_headers())
+        return CimeResponse[ChatSettings](**resp.json())
+
+    async def send_chat(self, message: str) -> CimeResponse[MessageResponse]:
+        resp = await self.client.post('/api/openapi/open/v1/chats/send', json={'message': message}, headers=self._get_headers())
+        return CimeResponse[MessageResponse](**resp.json())
+
+    async def search_categories(self, keyword: str, size: Optional[int] = None) -> CimeResponse[CategorySearchResponse]:
+        params = {'keyword': keyword}
+        if size is not None: params['size'] = size
+        resp = await self.client.get('/api/openapi/open/v1/categories/search', params=params, headers=self._get_headers())
+        return CimeResponse[CategorySearchResponse](**resp.json())
+
+    async def get_restrict_channels(self) -> CimeResponse[Any]:
+        resp = await self.client.get('/api/openapi/open/v1/restrict-channels', headers=self._get_headers())
+        return CimeResponse[Any](**resp.json())
+
+    async def restrict_channel(self, channel_id: str) -> CimeResponse[Any]:
+        resp = await self.client.post('/api/openapi/open/v1/restrict-channels', json={'channelId': channel_id}, headers=self._get_headers())
+        return CimeResponse[Any](**resp.json())
+
+    async def unrestrict_channel(self, channel_id: str) -> CimeResponse[Any]:
+        # httpx for DELETE with body needs 'content' or 'json'
+        resp = await self.client.request("DELETE", '/api/openapi/open/v1/restrict-channels', json={'channelId': channel_id}, headers=self._get_headers())
+        return CimeResponse[Any](**resp.json())
+
+    async def create_session(self, use_client_auth: bool = False) -> CimeResponse[SessionResponse]:
+        endpoint = '/api/openapi/open/v1/sessions/auth/client' if use_client_auth else '/api/openapi/open/v1/sessions/auth'
+        resp = await self.client.post(endpoint, headers=self._get_headers())
+        return CimeResponse[SessionResponse](**resp.json())

cime_py-1.0.0/cime/events.py

@@ -0,0 +1,52 @@
+import asyncio
+import json
+import websockets
+from typing import Callable, Coroutine, Any, Dict, Set
+
+class CimeEvents:
+    def __init__(self, url: str):
+        self.url = url
+        self.ws = None
+        self.handlers: Dict[str, Set[Callable[[Any], Coroutine]]] = {}
+        self.subscriptions: Set[str] = set()
+        self._running = False
+
+    def on(self, event_type: str, handler: Callable[[Any], Coroutine]):
+        if event_type not in self.handlers:
+            self.handlers[event_type] = set()
+        self.handlers[event_type].add(handler)
+
+    async def connect(self):
+        async with websockets.connect(self.url) as self.ws:
+            self._running = True
+            await self._resubscribe()
+            while self._running:
+                try:
+                    message_raw = await self.ws.recv()
+                    message = json.loads(message_raw)
+                    event_type = message.get("type")
+                    data = message.get("data")
+                    
+                    if event_type in self.handlers:
+                        for handler in self.handlers[event_type]:
+                            asyncio.create_task(handler(data))
+                except websockets.exceptions.ConnectionClosed:
+                    break
+        self._running = False
+
+    async def _resubscribe(self):
+        for topic in self.subscriptions:
+            await self.ws.send(json.dumps({"type": "SUBSCRIBE", "topic": topic}))
+
+    async def subscribe(self, topic: str):
+        self.subscriptions.add(topic)
+        if self.ws and not self.ws.closed:
+            await self.ws.send(json.dumps({"type": "SUBSCRIBE", "topic": topic}))
+
+    async def unsubscribe(self, topic: str):
+        self.subscriptions.remove(topic)
+        if self.ws and not self.ws.closed:
+            await self.ws.send(json.dumps({"type": "UNSUBSCRIBE", "topic": topic}))
+
+    def disconnect(self):
+        self._running = False

cime_py-1.0.0/cime/models.py

@@ -0,0 +1,80 @@
+from typing import List, Optional, Generic, TypeVar, Literal
+from pydantic import BaseModel
+from enum import Enum
+
+T = TypeVar('T')
+
+class CimeResponse(BaseModel, Generic[T]):
+    code: int
+    message: Optional[str] = None
+    content: T
+
+class UserChannelInfo(BaseModel):
+    channelId: str
+    channelName: str
+    channelHandle: str
+
+class Channel(BaseModel):
+    channelId: str
+    channelName: str
+    channelHandle: str
+    channelImageUrl: Optional[str] = None
+    channelDescription: str
+    followerCount: int
+
+class BulkChannelResponse(BaseModel):
+    data: List[Channel]
+
+class Live(BaseModel):
+    liveId: str
+    liveTitle: str
+    liveThumbnailImageUrl: Optional[str] = None
+    concurrentUserCount: int
+    openedDate: Optional[str] = None
+    adult: bool
+    tags: List[str]
+    categoryType: Optional[str] = None
+    liveCategory: Optional[str] = None
+    liveCategoryValue: Optional[str] = None
+    channelId: str
+    channelName: str
+    channelHandle: str
+    channelImageUrl: Optional[str] = None
+
+class Page(BaseModel):
+    next: Optional[int] = None
+
+class LiveListResponse(BaseModel):
+    data: List[Live]
+    page: Page
+
+class LiveSetting(BaseModel):
+    defaultLiveTitle: str
+    categoryType: Optional[str] = None
+    liveCategory: Optional[str] = None
+    tags: List[str]
+
+class ChatSettings(BaseModel):
+    chatAllowedGroup: Literal['ALL', 'FOLLOWER', 'MANAGER']
+    minFollowerMinute: int
+    followerSubscriberChatAllow: Optional[bool] = None
+
+class MessageResponse(BaseModel):
+    messageId: str
+
+class Category(BaseModel):
+    categoryId: str
+    categoryType: str
+    categoryValue: str
+    posterImageUrl: Optional[str] = None
+
+class CategorySearchResponse(BaseModel):
+    data: List[Category]
+
+class SessionResponse(BaseModel):
+    url: str
+
+class EventType(str, Enum):
+    CHAT = 'CHAT'
+    DONATION = 'DONATION'
+    SUBSCRIPTION = 'SUBSCRIPTION'

cime_py-1.0.0/cime.py.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: cime.py
+Version: 1.0.0
+Summary: Unofficial Python SDK for CI.ME OpenAPI
+Author-email: chocolily <medeia_beliar@naver.com>
+Project-URL: Homepage, https://github.com/choco-lily/cime.py
+Project-URL: Bug Tracker, https://github.com/choco-lily/cime.py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Requires-Dist: websockets
+Requires-Dist: pydantic
+Dynamic: license-file
+
+# cime.py
+
+CI.ME 공식 API를 활용한 비공식 Python SDK입니다.
+(Unofficial Python SDK using Official CI.ME OpenAPI)
+
+## Installation
+
+```bash
+pip install cime.py
+```
+
+## Quick Start
+
+### Async Client Initialization
+
+```python
+import asyncio
+from cime import CimeClient
+
+async def main():
+    async with CimeClient(
+        client_id='YOUR_CLIENT_ID',
+        client_secret='YOUR_CLIENT_SECRET'
+    ) as client:
+        # Use bearer token for user-specific actions
+        # client.bearer_token = 'YOUR_BEARER_TOKEN'
+        
+        me = await client.get_me()
+        print(f"My Channel: {me.content.channelName}")
+
+asyncio.run(main())
+```
+
+### WebSocket Events
+
+```python
+import asyncio
+from cime import CimeEvents, CimeClient
+
+async def on_chat(data):
+    print(f"New Chat: {data['message']}")
+
+async def main():
+    async with CimeClient(client_id='...', client_secret='...') as client:
+        session = await client.create_session()
+        events = CimeEvents(session.content.url)
+        
+        events.on("CHAT", on_chat)
+        await events.subscribe("CHAT")
+        
+        await events.connect()
+
+asyncio.run(main())
+```
+
+## Features
+
+- CI.ME REST API (User, Channel, Live, Chat, etc.) 완벽 지원
+- `httpx` 및 `websockets` 기반의 고성능 비동기 설계
+- Pydantic 모델을 통한 강력한 데이터 검증 및 타입 힌트 제공
+
+## License
+
+MIT

cime_py-1.0.0/cime.py.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+cime/__init__.py
+cime/client.py
+cime/events.py
+cime/models.py
+cime.py.egg-info/PKG-INFO
+cime.py.egg-info/SOURCES.txt
+cime.py.egg-info/dependency_links.txt
+cime.py.egg-info/requires.txt
+cime.py.egg-info/top_level.txt

cime_py-1.0.0/cime.py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cime_py-1.0.0/cime.py.egg-info/requires.txt

@@ -0,0 +1,3 @@
+httpx
+websockets
+pydantic

cime_py-1.0.0/cime.py.egg-info/top_level.txt

@@ -0,0 +1 @@
+cime

cime_py-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cime.py"
+version = "1.0.0"
+authors = [
+  { name="chocolily", email="medeia_beliar@naver.com" },
+]
+description = "Unofficial Python SDK for CI.ME OpenAPI"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "httpx",
+    "websockets",
+    "pydantic",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/choco-lily/cime.py"
+"Bug Tracker" = "https://github.com/choco-lily/cime.py/issues"

cime_py-1.0.0/setup.cfg

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