vrchatapi-async 1.20.8.dev1__py3-none-any.whl

vrchatapi/models/world_publish_status.py

@@ -0,0 +1,234 @@
+# coding: utf-8
+
+"""
+    VRChat API Documentation
+
+
+    The version of the OpenAPI document: 1.20.8
+    Contact: vrchatapi.lpv0t@aries.fyi
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from collections.abc import Mapping as _Mapping
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, cast as _cast
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+_OPENAPI_GENERATOR_TO_DICT = "_openapi_generator_to_dict"
+
+
+def _get_openapi_to_dict(value: Any) -> Any:
+    # Reciprocal function references preserve inherited generated methods
+    # without reserving model member names. Checking both directions also
+    # rejects overrides whose decorators copy function attributes.
+    to_dict = getattr(value, "to_dict", None)
+    type_to_dict = getattr(type(value), "to_dict", None)
+    if (
+        not callable(to_dict)
+        or getattr(to_dict, "__func__", None) is not type_to_dict
+    ):
+        return None
+
+    openapi_to_dict = getattr(
+        type_to_dict, _OPENAPI_GENERATOR_TO_DICT, None
+    )
+    if (
+        not callable(openapi_to_dict)
+        or getattr(
+            openapi_to_dict,
+            _OPENAPI_GENERATOR_TO_DICT,
+            None,
+        ) is not type_to_dict
+    ):
+        return None
+    return openapi_to_dict
+
+
+def _to_legacy_item(value: Any, serialize: bool) -> Any:
+    to_dict = getattr(value, "to_dict", None)
+    if _get_openapi_to_dict(value) is not None and callable(to_dict):
+        return to_dict(serialize=serialize)
+    if callable(to_dict):
+        return to_dict()
+    return value
+
+
+def _to_legacy_value(value: Any, serialize: bool) -> Any:
+    # python-legacy converted only immediate list elements or dictionary values:
+    # https://github.com/OpenAPITools/openapi-generator/blob/c84b949df1a9ec04ba75989cb49b45c940c2f694/modules/openapi-generator/src/main/resources/python-legacy/model.mustache#L203-L231
+    if isinstance(value, list):
+        return [_to_legacy_item(item, serialize) for item in value]
+    if isinstance(value, dict):
+        return {
+            key: _to_legacy_item(item, serialize)
+            for key, item in value.items()
+        }
+    return _to_legacy_item(value, serialize)
+
+
+def _to_openapi_value(value: Any) -> Any:
+    if isinstance(value, list):
+        return [_to_openapi_value(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _to_openapi_value(item) for key, item in value.items()}
+
+    to_openapi_dict = _get_openapi_to_dict(value)
+    if to_openapi_dict is not None:
+        return to_openapi_dict(value)
+
+    to_dict = getattr(value, "to_dict", None)
+    if callable(to_dict):
+        return to_dict()
+    return value
+
+
+class WorldPublishStatus(BaseModel):
+    """
+    WorldPublishStatus
+
+    Attributes:
+      openapi_types (dict): The key is attribute name
+                            and the value is attribute type.
+      attribute_map (dict): The key is attribute name
+                            and the value is json key in definition.
+    """ # noqa: E501
+    can_publish: Optional[StrictBool] = Field(default=None, validation_alias=AliasChoices("canPublish", "can_publish"), serialization_alias="canPublish")
+    openapi_types: ClassVar[Dict[str, str]] = {
+        "can_publish": "bool"
+    }
+
+    attribute_map: ClassVar[Dict[str, str]] = {
+        "can_publish": "canPublish"
+    }
+    __properties: ClassVar[List[str]] = ["canPublish"]
+
+    @classmethod
+    def __preprocess_input_names(
+        cls,
+        obj: Any,
+        remove_hidden_storage_names: bool = True,
+    ) -> Any:
+        if not isinstance(obj, _Mapping):
+            return obj
+        obj = dict(obj)
+        if "canPublish" not in obj and "can_publish" in obj:
+            obj["canPublish"] = obj["can_publish"]
+        obj.pop("can_publish", None)
+        return obj
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        extra="forbid",
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model"""
+        return pprint.pformat(self.to_dict())
+
+    def __repr__(self) -> str:
+        """For print and pprint"""
+        return self.to_str()
+
+    def __eq__(self, other: object) -> bool:
+        """Returns true if both objects are equal"""
+        if not isinstance(other, WorldPublishStatus):
+            return False
+
+        return self.to_dict() == other.to_dict()
+
+    def __ne__(self, other: object) -> bool:
+        """Returns true if both objects are not equal"""
+        if not isinstance(other, WorldPublishStatus):
+            return True
+
+        return not (self == other)
+
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        to_openapi_dict = _get_openapi_to_dict(self)
+        if to_openapi_dict is not None:
+            return json.dumps(to_jsonable_python(to_openapi_dict(self)))
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of WorldPublishStatus from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self, serialize: bool = False) -> Dict[str, Any]:
+        """Return all declared model fields using public or wire names."""
+        return {
+            ("canPublish" if serialize else "can_publish"): _to_legacy_value(getattr(self, "can_publish", None), serialize),
+        }
+
+    def __openapi_generator_modern_projection(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    setattr(
+        to_dict,
+        _OPENAPI_GENERATOR_TO_DICT,
+        __openapi_generator_modern_projection,
+    )
+    setattr(
+        __openapi_generator_modern_projection,
+        _OPENAPI_GENERATOR_TO_DICT,
+        to_dict,
+    )
+    del __openapi_generator_modern_projection
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WorldPublishStatus from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        obj = _cast(
+            Dict[str, Any],
+            cls.__preprocess_input_names(
+                obj,
+                remove_hidden_storage_names=True,
+            ),
+        )
+
+        _obj = cls.model_validate({
+            "canPublish": obj.get("canPublish") if obj.get("canPublish") is not None else True
+        })
+        return _obj
+
+

vrchatapi/rest.py

@@ -0,0 +1,303 @@
+# coding: utf-8
+
+"""
+    VRChat API Documentation
+
+
+    The version of the OpenAPI document: 1.20.8
+    Contact: vrchatapi.lpv0t@aries.fyi
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import io
+import json
+import re
+import ssl
+from typing import Any, Dict, Optional, Union
+
+import aiohttp
+import aiohttp_retry
+
+from vrchatapi.exceptions import ApiException, ApiValueError
+from http.cookiejar import CookieJar
+from urllib.request import Request as _UrlLibRequest
+
+RESTResponseType = aiohttp.ClientResponse
+
+ALLOW_RETRY_METHODS = frozenset({'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PUT', 'TRACE'})
+
+
+class _CookieHeaderAdapter:
+    """Minimal ``email.message``-like view over aiohttp headers for http.cookiejar."""
+
+    def __init__(self, headers) -> None:
+        self._headers = headers
+
+    def get_all(self, name, default=None):
+        return self._headers.getall(name, default)
+
+
+class _CookieResponseAdapter:
+    """Adapter exposing ``info()`` so ``CookieJar.extract_cookies`` works with aiohttp."""
+
+    def __init__(self, headers) -> None:
+        self._headers = headers
+
+    def info(self):
+        return _CookieHeaderAdapter(self._headers)
+
+class RESTResponse(io.IOBase):
+
+    def __init__(self, resp) -> None:
+        self.response = resp
+        self.status = resp.status
+        self.reason = resp.reason
+        self.data = None
+
+    async def read(self):
+        if self.data is None:
+            self.data = await self.response.read()
+        return self.data
+
+    @property
+    def headers(self):
+        """Returns a CIMultiDictProxy of response headers."""
+        return self.response.headers
+
+    def getheaders(self):
+        """Returns a CIMultiDictProxy of the response headers; use ``headers`` instead."""
+        return self.response.headers
+
+    def getheader(self, name, default=None):
+        """Returns a given response header; use ``headers.get()`` instead."""
+        return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+    def __init__(self, configuration) -> None:
+
+        # Keep a reference so factory methods (_create_pool_manager / _create_connector)
+        # and subclasses can read extension fields like trace_configs.
+        self.configuration = configuration
+
+        # maxsize is number of requests to host that are allowed in parallel
+        self.maxsize = configuration.connection_pool_maxsize
+
+        self.ssl_context = ssl.create_default_context(
+            cafile=configuration.ssl_ca_cert,
+            cadata=configuration.ca_cert_data,
+        )
+        if configuration.cert_file:
+            self.ssl_context.load_cert_chain(
+                configuration.cert_file, keyfile=configuration.key_file
+            )
+
+        if not configuration.verify_ssl:
+            self.ssl_context.check_hostname = False
+            self.ssl_context.verify_mode = ssl.CERT_NONE
+
+        self.proxy = configuration.proxy
+        self.proxy_headers = configuration.proxy_headers
+
+        retries = configuration.retries
+        if retries is None:
+            self._effective_retry_options = None
+        elif isinstance(retries, aiohttp_retry.RetryOptionsBase):
+            self._effective_retry_options = retries
+        elif isinstance(retries, int):
+            self._effective_retry_options = aiohttp_retry.ExponentialRetry(
+                attempts=retries,
+                factor=2.0,
+                start_timeout=0.1,
+                max_timeout=120.0
+            )
+        else:
+            self._effective_retry_options = None
+
+        self.pool_manager: Optional[aiohttp.ClientSession] = None
+        self.retry_client: Optional[aiohttp_retry.RetryClient] = None
+
+        # VRChatAPI: Init global cookie storage
+        self.cookie_jar = CookieJar()
+
+    async def close(self) -> None:
+        if self.pool_manager:
+            await self.pool_manager.close()
+        if self.retry_client is not None:
+            await self.retry_client.close()
+
+    def _create_connector(self) -> aiohttp.TCPConnector:
+        """Build the TCPConnector used by the ClientSession.
+
+        Override in a subclass to customize DNS resolver, keepalive, etc.
+        """
+        kwargs: Dict[str, Any] = {
+            "limit": self.maxsize,
+            "ssl": self.ssl_context,
+        }
+        limit_per_host = getattr(self.configuration, "tcp_connector_limit_per_host", None)
+        if limit_per_host is not None:
+            kwargs["limit_per_host"] = limit_per_host
+        return aiohttp.TCPConnector(**kwargs)
+
+    def _create_pool_manager(self) -> aiohttp.ClientSession:
+        """Build the aiohttp.ClientSession used as the connection pool.
+
+        Override in a subclass to fully customize the session (e.g. attach
+        aiohttp.TraceConfig, swap json_serialize, etc.). Typed Configuration
+        fields (trace_configs / client_session_kwargs) are read via getattr
+        so older Configuration objects remain compatible.
+        """
+        extra = getattr(self.configuration, "client_session_kwargs", None)
+        kwargs: Dict[str, Any] = {
+            "connector": self._create_connector(),
+            "trust_env": False,
+        }
+        trace_configs = getattr(self.configuration, "trace_configs", None)
+        if trace_configs is not None:
+            kwargs["trace_configs"] = trace_configs
+        if extra:
+            kwargs.update(extra)
+        return aiohttp.ClientSession(**kwargs)
+
+    async def request(
+        self,
+        method,
+        url,
+        headers=None,
+        body=None,
+        post_params=None,
+        _request_timeout=None
+    ):
+        """Execute request
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        """
+        method = method.upper()
+        assert method in [
+            'GET',
+            'HEAD',
+            'DELETE',
+            'POST',
+            'PUT',
+            'PATCH',
+            'OPTIONS'
+        ]
+
+        if post_params and body:
+            raise ApiValueError(
+                "body parameter cannot be used with post_params parameter."
+            )
+
+        post_params = post_params or {}
+        headers = headers or {}
+        # url already contains the URL query string
+        if isinstance(_request_timeout, tuple) and len(_request_timeout) == 2:
+            timeout = aiohttp.ClientTimeout(
+                connect=_request_timeout[0],
+                sock_read=_request_timeout[1],
+            )
+        else:
+            timeout = aiohttp.ClientTimeout(total=_request_timeout or 5 * 60)
+
+        if 'Content-Type' not in headers:
+            headers['Content-Type'] = 'application/json'
+
+        args = {
+            "method": method,
+            "url": url,
+            "timeout": timeout,
+            "headers": headers
+        }
+
+        if self.proxy:
+            args["proxy"] = self.proxy
+        if self.proxy_headers:
+            args["proxy_headers"] = self.proxy_headers
+
+        # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+        if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+            if re.search('json', headers['Content-Type'], re.IGNORECASE):
+                if body is not None:
+                    body = json.dumps(body)
+                if body is None and post_params:
+                    body = json.dumps(dict(post_params))
+                args["data"] = body
+            elif headers['Content-Type'] == 'application/x-www-form-urlencoded':
+                args["data"] = aiohttp.FormData(post_params)
+            elif headers['Content-Type'] == 'multipart/form-data':
+                # must del headers['Content-Type'], or the correct
+                # Content-Type which generated by aiohttp
+                del headers['Content-Type']
+                data = aiohttp.FormData()
+                for param in post_params:
+                    k, v = param
+                    if isinstance(v, tuple) and len(v) == 3:
+                        data.add_field(
+                            k,
+                            value=v[1],
+                            filename=v[0],
+                            content_type=v[2]
+                        )
+                    else:
+                        # Ensures that dict objects are serialized
+                        if isinstance(v, dict):
+                            v = json.dumps(v)
+                        elif isinstance(v, int):
+                            v = str(v)
+                        data.add_field(k, v)
+                args["data"] = data
+
+            # Pass a `bytes` or `str` parameter directly in the body to support
+            # other content types than Json when `body` argument is provided
+            # in serialized form
+            elif isinstance(body, str) or isinstance(body, bytes):
+                args["data"] = body
+            else:
+                # Cannot generate the request from given parameters
+                msg = """Cannot prepare a request message for provided
+                         arguments. Please check that your arguments match
+                         declared content type."""
+                raise ApiException(status=0, reason=msg)
+
+        pool_manager: Union[aiohttp.ClientSession, aiohttp_retry.RetryClient]
+
+        # https pool manager
+        if self.pool_manager is None:
+            self.pool_manager = self._create_pool_manager()
+        pool_manager = self.pool_manager
+
+        if self._effective_retry_options is not None and method in ALLOW_RETRY_METHODS:
+            if self.retry_client is None:
+                self.retry_client = aiohttp_retry.RetryClient(
+                    client_session=self.pool_manager,
+                    retry_options=self._effective_retry_options
+                )
+            pool_manager = self.retry_client
+
+        # VRChatAPI: Attach session cookies to the outgoing request
+        mock_request_object = _UrlLibRequest(url=url, method=method, headers=headers)
+        self.cookie_jar.add_cookie_header(mock_request_object)
+        if "Cookie" in mock_request_object.unredirected_hdrs:
+            headers["Cookie"] = mock_request_object.unredirected_hdrs["Cookie"]
+
+        r = await pool_manager.request(**args)
+
+        # VRChatAPI: Store any cookies set by the response for later requests
+        self.cookie_jar.extract_cookies(_CookieResponseAdapter(r.headers), mock_request_object)
+
+        return RESTResponse(r)

vrchatapi_async-1.20.8.dev1.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: vrchatapi-async
+Version: 1.20.8.dev1
+Summary: VRChat API Library for Python (async version)
+Home-page: https://github.com/hi94740/vrchatapi-python-async
+Author: hi94740
+Author-email: hi94740@qq.com
+License: MIT
+Keywords: vrchat,vrchatapi,vrc
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: aiohttp>=3.13.5
+Requires-Dist: aiohttp-retry>=2.8.3
+Requires-Dist: pydantic>=2.11
+Requires-Dist: typing-extensions>=4.7.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+![](https://github.com/vrchatapi/vrchatapi.github.io/blob/main/static/assets/img/lang/lang_python_banner_1500x300.png?raw=true)
+
+# VRChat API Library for Python (async)
+
+A Python client to interact with the unofficial VRChat API. Supports all REST calls specified in the [API specification](https://github.com/vrchatapi/specification).
+
+This is an **asynchronous** (asyncio + aiohttp) adaptation of [VRChatAPI-Python](https://github.com/vrchatapi/vrchatapi-python). All API
+methods are coroutines and must be awaited.
+
+## Disclaimer
+
+This is the official response of the VRChat Team (from Tupper more specifically) on the usage of the VRChat API.
+
+> Use of the API using applications other than the approved methods (website, VRChat application) are not officially supported. You may use the API for your own application, but keep these guidelines in mind:
+> * We do not provide documentation or support for the API.
+> * Do not make queries to the API more than once per 60 seconds.
+> * Abuse of the API may result in account termination.
+> * Access to API endpoints may break at any given time, with no warning.
+
+As stated, this documentation was not created with the help of the official VRChat team. Therefore this documentation is not an official documentation of the VRChat API and may not be always up to date with the latest versions. If you find that a page or endpoint is not longer valid please create an issue and tell us so we can fix it.
+
+## Getting Started
+
+First add the package to to your project:
+```bash
+pip install vrchatapi-async
+```
+
+Below is an example on how to login to the API and fetch your own user information.
+
+```python
+import asyncio
+
+# Step 1. We begin with creating a Configuration, which contains the username and password for authentication.
+import vrchatapi
+from vrchatapi.api import authentication_api
+from vrchatapi.exceptions import UnauthorizedException
+from vrchatapi.models.two_factor_auth_code import TwoFactorAuthCode
+from vrchatapi.models.two_factor_email_code import TwoFactorEmailCode
+
+
+async def main():
+    configuration = vrchatapi.Configuration(
+        username = 'username',
+        password = 'password',
+    )
+
+    # Step 2. VRChat consists of several API's (WorldsApi, UsersApi, FilesApi, NotificationsApi, FriendsApi, etc...)
+    # Here we enter a context of the API Client and instantiate the Authentication API which is required for logging in.
+
+    # Enter a context with an instance of the API client
+    async with vrchatapi.ApiClient(configuration) as api_client:
+        # Set our User-Agent as per VRChat Usage Policy
+        api_client.user_agent = "ExampleProgram/0.0.1 my@email.com"
+
+        # Instantiate instances of API classes
+        auth_api = authentication_api.AuthenticationApi(api_client)
+
+        try:
+            # Step 3. Calling getCurrentUser on Authentication API logs you in if the user isn't already logged in.
+            current_user = await auth_api.get_current_user()
+        except UnauthorizedException as e:
+            if e.status == 200:
+                if "Email 2 Factor Authentication" in e.reason:
+                    # Step 3.5. Calling email verify2fa if the account has 2FA disabled
+                    await auth_api.verify2_fa_email_code(two_factor_email_code=TwoFactorEmailCode(input("Email 2FA Code: ")))
+                elif "2 Factor Authentication" in e.reason:
+                    # Step 3.5. Calling verify2fa if the account has 2FA enabled
+                    await auth_api.verify2_fa(two_factor_auth_code=TwoFactorAuthCode(input("2FA Code: ")))
+                current_user = await auth_api.get_current_user()
+            else:
+                print("Exception when calling API: %s
+", e)
+        except vrchatapi.ApiException as e:
+            print("Exception when calling API: %s
+", e)
+
+        print("Logged in as:", current_user.display_name)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+See [Examples](examples/README.md) for more example usage on getting started.
+
+## Async API notes
+
+Compared to [the synchronous SDK](https://github.com/vrchatapi/vrchatapi-python), this version changes the calling convention:
+
+- Every API method (`foo`, `foo_with_http_info`, `foo_without_preload_content`)
+  is an `async def` coroutine and must be awaited.
+- `ApiClient` is used as an async context manager (`async with ... as api_client`).
+- The `async_req` parameter and the thread-pool based `async_req=True` usage are
+  removed; calls are natively asynchronous.
+- `foo_with_http_info()` returns an `ApiResponse` object (`status_code`,
+  `headers`, `data`, `raw_data`) instead of a `(data, status, headers)` tuple.
+- `foo_without_preload_content()` returns the raw aiohttp response for
+  streaming; the legacy `_preload_content=False` parameter is removed.
+- The session `CookieJar`, the readable 2FA errors
+  (`UnauthorizedException` with status 200), the URL-encoded basic auth, the
+  `~()` safe path-parameter charset and the lowercase boolean query parameters
+  behave exactly like the synchronous SDK.
+
+## Contributing
+
+Contributions are welcome, but do not add features that should be handled by the OpenAPI specification.
+