async def download(self, path: str, load_chunk_size: int = 1024) -> None: """ニコニコ動画の動画をダウンロードします。 mp4形式でダウンロードされます。 Examples -------- ```python url = "https://www.nicovideo.jp/watch/sm9720246" async with NicoNicoVideoAsync(url) as nico: data = await nico.get_info() title = data["video"]["title"] await nico.download(title + ".mp4") ``` Notes ----- もし`async with`構文を使用しないでダウンロードする場合は、ダウンロード前に`connect`を、ダウンロード終了後に`close`を実行してください。 動画データの通信に必要なHeartbeatが永遠に動き続けることになります。 Parameters ---------- path : str ダウンロードするニコニコ動画の動画の保存先です。 load_chunk_size : int, default 1024 一度にどれほどの量をダウンロードするかです。""" self.print("Now loading...") url = await self.get_download_link() params = ( ("ht2_nicovideo", self.result_data["content_auth"]["content_auth_info"]["value"]), ) headers = self._headers[1] headers["Content-Type"] = "video/mp4" BASE = "Downloading video... :" self.print(BASE, "Now loading...", first="\r", end="") async with ClientSession(raise_for_status=True) as session: async with session.get(url, headers=headers, params=params) as r: size, now_size = r.content_length, 0 self.print(BASE, "Making a null file...", first="\r", end="") async with async_open(path, "wb") as f: await f.write(b"") async with async_open(path, "ab") as f: async for chunk in r.content.iter_chunked(load_chunk_size): if chunk: now_size += len(chunk) await f.write(chunk) self.print( BASE, f"{int(now_size/size*100)}% ({now_size}/{size})", first="\r", end="") self.print("Done.")
async def load(self, source: PathLike, buffer_size: int = 16384) -> None: path = Path(source) self.filename = path.name async with async_open(path, "rb") as file_: data = await file_.read(buffer_size) while data != b"": self.stream.write(data) data = await file_.read(buffer_size)
async def restore_state(): global trolls try: async with async_open(STATE_PATH) as state_file: state = loads(await state_file.read()) trolls = state["trolls"] except (FileNotFoundError, JSONDecodeError, TypeError) as exc: pass
async def test_aiofile_upload_download(objectService, tmp_path): src = tmp_path / "src" dest = tmp_path / "dest" data = secrets.token_bytes(102400) with open(src, "wb") as f: f.write(data) name = f"taskcluster/test/client-py/{taskcluster.slugid.v4()}" async with async_open(src, "rb") as file: async def readerFactory(): file.seek(0) return file await upload.upload( projectId="taskcluster", name=name, contentType="text/plain", contentLength=len(data), expires=taskcluster.fromNow('1 hour'), readerFactory=readerFactory, objectService=objectService) async with async_open(dest, "wb") as file: async def writerFactory(): file.seek(0) file.truncate() return file contentType = await download.download( name=name, writerFactory=writerFactory, objectService=objectService) with open(dest, "rb") as f: got = f.read() assert got == data assert contentType == 'text/plain'
async def save(self, destination: PathLike, buffer_size: int = 16384) -> None: # type: ignore """Save the file to the destination. Arguments: destination: A filename (str) or file object to write to. buffer_size: Buffer size to keep in memory. """ async with async_open(destination, "wb") as file_: data = self.stream.read(buffer_size) while data != b"": await file_.write(data) data = self.stream.read(buffer_size)
async def send_file( filename: FilePath, add_etags: bool = True, cache_timeout: Optional[int] = None, last_modified: Optional[datetime] = None, ) -> Response: """Return a Reponse to send the filename given. Arguments: filename: The filename (path) to send, remember to use :func:`safe_join`. add_etags: Set etags based on the filename, size and modification time. cache_timeout: Time in seconds for the response to be cached. last_modified: Used to override the last modified value. """ file_path = os.fspath(filename) mimetype = mimetypes.guess_type( os.path.basename(file_path))[0] or DEFAULT_MIMETYPE async with async_open(file_path, mode='rb') as file_: data = await file_.read() response = current_app.response_class(data, mimetype=mimetype) if last_modified is not None: response.last_modified = last_modified else: response.last_modified = datetime.fromtimestamp( os.path.getmtime(file_path)) response.cache_control.public = True cache_timeout = cache_timeout or current_app.get_send_file_max_age( file_path) if cache_timeout is not None: response.cache_control.max_age = cache_timeout response.expires = datetime.utcnow() + timedelta(seconds=cache_timeout) if add_etags: file_tag = file_path.encode('utf-8') if isinstance(file_path, str) else file_path response.set_etag( '{}-{}-{}'.format( os.path.getmtime(file_path), os.path.getsize(file_path), adler32(file_tag), ), ) return response
async def open_resource( self, path: FilePath, mode: str = "rb", ) -> AiofilesContextManager[None, None, AsyncBufferedReader]: """Open a file for reading. Use as .. code-block:: python async with await app.open_resource(path) as file_: await file_.read() """ if mode not in {"r", "rb"}: raise ValueError("Files can only be opened for reading") return async_open(self.root_path / file_path_to_path(path), mode) # type: ignore
async def save_state(): async with async_open(STATE_PATH, "w") as state_file: state = {"trolls": trolls} await state_file.write(dumps(state))
async def __aenter__(self) -> "FileBody": self.file_manager = async_open(self.file_path, mode="rb") self.file = await self.file_manager.__aenter__() await self.file.seek(self.begin) return self
async def setup_database(self): db = await asyncpg.create_pool(**self.credentials) async with async_open("setup.sql") as sql: await db.execute(await sql.read()) self.bot.db = db
async def write_file_to_tmp_dir(path: str, body: bytes): async with async_open(path, 'wb+') as f: await f.write(body)
async def send_file(filename: str) -> Response: mimetype = mimetypes.guess_type( os.path.basename(filename))[0] or DEFAULT_MIMETYPE async with async_open(filename, mode='rb') as file_: data = await file_.read() return current_app.response_class(data, mimetype=mimetype)