# Project export: Econvert This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: Cal Hacks 10.0 - Tagline: Coverts from USD to any currency - Devpost: https://devpost.com/software/econvert - GitHub: https://github.com/DanielSolano1/Econvert.git - Team: 1 GitHub contributor(s) — Daniel Solano (1 commits) ## Devpost submission (written by the team) No Devpost description available. ## README (from the GitHub repository) No README available. ## Detected evidence (automated analysis) Indexed codebase: 2820 recognized source files, 32785 KB. - C (language) — detected in the code - CSS (language) — detected in the code - HTML (language) — detected in the code - JavaScript (language) — detected in the code - Python (language) — detected in the code ## Codebase structure (from repository index) ### Files (120 of 3655) ``` calhacks1/.DS_Store calhacks1/.gitignore calhacks1/calhacks1.env/bin/activate calhacks1/calhacks1.env/bin/activate.csh calhacks1/calhacks1.env/bin/activate.fish calhacks1/calhacks1.env/bin/Activate.ps1 calhacks1/calhacks1.env/bin/alembic calhacks1/calhacks1.env/bin/gunicorn calhacks1/calhacks1.env/bin/httpx calhacks1/calhacks1.env/bin/mako-render calhacks1/calhacks1.env/bin/markdown-it calhacks1/calhacks1.env/bin/normalizer calhacks1/calhacks1.env/bin/openai calhacks1/calhacks1.env/bin/pip calhacks1/calhacks1.env/bin/pip 2 calhacks1/calhacks1.env/bin/pip3 calhacks1/calhacks1.env/bin/pip3 2 calhacks1/calhacks1.env/bin/pip3.11 calhacks1/calhacks1.env/bin/pip3.11 2 calhacks1/calhacks1.env/bin/pipdeptree calhacks1/calhacks1.env/bin/pygmentize calhacks1/calhacks1.env/bin/python calhacks1/calhacks1.env/bin/python3 calhacks1/calhacks1.env/bin/python3.11 calhacks1/calhacks1.env/bin/reflex calhacks1/calhacks1.env/bin/tabulate calhacks1/calhacks1.env/bin/together calhacks1/calhacks1.env/bin/tqdm calhacks1/calhacks1.env/bin/uvicorn calhacks1/calhacks1.env/bin/watchfiles calhacks1/calhacks1.env/bin/watchmedo calhacks1/calhacks1.env/lib/python3.11/site-packages/_distutils_hack/__init__.py calhacks1/calhacks1.env/lib/python3.11/site-packages/_distutils_hack/override.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp-3.8.6.dist-info/INSTALLER calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp-3.8.6.dist-info/LICENSE.txt calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp-3.8.6.dist-info/METADATA calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp-3.8.6.dist-info/RECORD calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp-3.8.6.dist-info/top_level.txt calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp-3.8.6.dist-info/WHEEL calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/__init__.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_cparser.pxd calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_find_header.pxd calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_headers.pxi calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_helpers.pyi calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_helpers.pyx calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_http_parser.pyx calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_http_writer.pyx calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/_websocket.pyx calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_cparser.pxd.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_find_header.pxd.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_helpers.pyi.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_helpers.pyx.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_http_parser.pyx.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_http_writer.pyx.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/_websocket.pyx.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/.hash/hdrs.py.hash calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/abc.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/base_protocol.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/client_exceptions.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/client_proto.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/client_reqrep.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/client_ws.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/client.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/connector.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/cookiejar.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/formdata.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/hdrs.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/helpers.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/http_exceptions.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/http_parser.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/http_websocket.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/http_writer.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/http.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/locks.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/log.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/multipart.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/payload_streamer.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/payload.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/py.typed calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/pytest_plugin.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/resolver.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/streams.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/tcp_helpers.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/test_utils.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/tracing.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/typedefs.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_app.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_exceptions.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_fileresponse.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_log.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_middlewares.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_protocol.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_request.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_response.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_routedef.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_runner.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_server.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_urldispatcher.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web_ws.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/web.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiohttp/worker.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal-1.3.1.dist-info/INSTALLER calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal-1.3.1.dist-info/LICENSE calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal-1.3.1.dist-info/METADATA calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal-1.3.1.dist-info/RECORD calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal-1.3.1.dist-info/top_level.txt calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal-1.3.1.dist-info/WHEEL calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal/__init__.py calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal/__init__.pyi calhacks1/calhacks1.env/lib/python3.11/site-packages/aiosignal/py.typed calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/entry_points.txt calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/INSTALLER calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/LICENSE calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/METADATA calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/RECORD calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/top_level.txt calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic-1.12.1.dist-info/WHEEL calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic/__init__.py calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic/__main__.py calhacks1/calhacks1.env/lib/python3.11/site-packages/alembic/autogenerate/__init__.py [3535 more files omitted for size] ``` ### Dependencies - calhacks1/requirements.txt: reflex@==0.3.1 ### Recent commits (newest first) - code ## Key source files (fetched from GitHub, selected and truncated for size) ### calhacks1/calhacks1.env/lib/python3.11/site-packages/httpcore-0.17.3.dist-info/LICENSE.md ```markdown Copyright © 2020, [Encode OSS Ltd](https://www.encode.io/). All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/idna-3.4.dist-info/LICENSE.md ```markdown BSD 3-Clause License Copyright (c) 2013-2021, Kim Davies All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ``` ### calhacks1/requirements.txt ``` reflex==0.3.1 ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/watchfiles/cli.py ```python import argparse import logging import os import shlex import sys from pathlib import Path from textwrap import dedent from typing import Any, Callable, List, Optional, Tuple, Union, cast from . import Change from .filters import BaseFilter, DefaultFilter, PythonFilter from .run import detect_target_type, import_string, run_process from .version import VERSION logger = logging.getLogger('watchfiles.cli') def resolve_path(path_str: str) -> Path: path = Path(path_str) if not path.exists(): raise FileNotFoundError(path) else: return path.resolve() def cli(*args_: str) -> None: """ Watch one or more directories and execute either a shell command or a python function on file changes. Example of watching the current directory and calling a python function: watchfiles foobar.main Example of watching python files in two local directories and calling a shell command: watchfiles --filter python 'pytest --lf' src tests See https://watchfiles.helpmanual.io/cli/ for more information. """ args = args_ or sys.argv[1:] parser = argparse.ArgumentParser( prog='watchfiles', description=dedent((cli.__doc__ or '').strip('\n')), formatter_class=argparse.RawTextHelpFormatter, ) parser.add_argument('target', help='Command or dotted function path to run') parser.add_argument( 'paths', nargs='*', default='.', help='Filesystem paths to watch, defaults to current directory' ) parser.add_argument( '--ignore-paths', nargs='?', type=str, help=( 'Specify directories to ignore, ' 'to ignore multiple paths use a comma as separator, e.g. "env" or "env,node_modules"' ), ) parser.add_argument( '--target-type', nargs='?', type=str, default='auto', choices=['command', 'function', 'auto'], help=( 'Whether the target should be intercepted as a shell command or a python function, ' 'defaults to "auto" which infers the target type from the target string' ), ) parser.add_argument( '--filter', nargs='?', type=str, default='default', help=( 'Which files to watch, defaults to "default" which uses the "DefaultFilter", ' '"python" uses the "PythonFilter", "all" uses no filter, ' 'any other value is interpreted as a python function/class path which is imported' ), ) parser.add_argument( '--args', nargs='?', type=str, help='Arguments to set on sys.argv before calling target function, used only if the target is a function', ) parser.add_argument('--verbose', action='store_true', help='Set log level to "debug", wins over `--verbosity`') parser.add_argument( '--non-recursive', action='store_true', help='Do not watch for changes in sub-directories recursively' ) parser.add_argument( '--verbosity', nargs='?', type=str, default='info', choices=['warning', 'info', 'debug'], help='Log level, defaults to "info"', ) parser.add_argument( '--sigint-timeout', nargs='?', type=int, default=5, help='How long to wait for the sigint timeout before sending sigkill.', ) parser.add_argument( '--sigkill-timeout', nargs='?', type=int, default=1, help='How long to wait for the sigkill timeout before issuing a timeout exception.', ) parser.add_argument('--version', '-V', action='version', version=f'%(prog)s v{VERSION}') arg_namespace = parser.parse_args(args) if arg_namespace.verbose: log_level = logging.DEBUG else: log_level = getattr(logging, arg_namespace.verbosity.upper()) hdlr = logging.StreamHandler() hdlr.setLevel(log_level) hdlr.setFormatter(logging.Formatter(fmt='[%(asctime)s] %(message)s', datefmt='%H:%M:%S')) wg_logger = logging.getLogger('watchfiles') wg_logger.addHandler(hdlr) wg_logger.setLevel(log_level) if arg_namespace.target_type == 'auto': target_type = detect_target_type(arg_namespace.target) else: target_type = arg_namespace.target_type if target_type == 'function': logger.debug('target_type=function, attempting import of "%s"', arg_namespace.target) import_exit(arg_namespace.target) if arg_namespace.args: sys.argv = [arg_namespace.target] + shlex.split(arg_namespace.args) elif arg_namespace.args: logger.warning('--args is only used when the target is a function') try: paths = [resolve_path(p) for p in arg_namespace.paths] except FileNotFoundError as e: print(f'path "{e}" does not exist', file=sys.stderr) sys.exit(1) watch_filter, watch_filter_str = build_filter(arg_namespace.filter, arg_namespace.ignore_paths) logger.info( 'watchfiles v%s 👀 path=%s target="%s" (%s) filter=%s...', VERSION, ', '.join(f'"{p}"' for p in paths), arg_namespace.target, target_type, watch_filter_str, ) run_process( *paths, target=arg_namespace.target, target_type=target_type, watch_filter=watch_filter, debug=log_level == logging.DEBUG, sigint_timeout=arg_namespace.sigint_timeout, sigkill_timeout=arg_namespace.sigkill_timeout, recursive=not arg_namespace.non_recursive, ) def import_exit(function_path: str) -> Any: cwd = os.getcwd() if cwd not in sys.path: sys.path.append(cwd) try: return import_string(function_path) except ImportError as e: print(f'ImportError: {e}', file=sys.stderr) sys.exit(1) def build_filter( filter_name: str, ignore_paths_str: Optional[str] ) -> Tuple[Union[None, DefaultFilter, Callable[[Change, str], [truncated — 1192 more characters] ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/tqdm/cli.py ```python """ Module version for monitoring CLI pipes (`... | python -m tqdm | ...`). """ import logging import re import sys from ast import literal_eval as numeric from .std import TqdmKeyError, TqdmTypeError, tqdm from .version import __version__ __all__ = ["main"] log = logging.getLogger(__name__) def cast(val, typ): log.debug((val, typ)) if " or " in typ: for t in typ.split(" or "): try: return cast(val, t) except TqdmTypeError: pass raise TqdmTypeError(val + ' : ' + typ) # sys.stderr.write('\ndebug | `val:type`: `' + val + ':' + typ + '`.\n') if typ == 'bool': if (val == 'True') or (val == ''): return True elif val == 'False': return False else: raise TqdmTypeError(val + ' : ' + typ) try: return eval(typ + '("' + val + '")') except Exception: if typ == 'chr': return chr(ord(eval('"' + val + '"'))).encode() else: raise TqdmTypeError(val + ' : ' + typ) def posix_pipe(fin, fout, delim=b'\\n', buf_size=256, callback=lambda float: None, callback_len=True): """ Params ------ fin : binary file with `read(buf_size : int)` method fout : binary file with `write` (and optionally `flush`) methods. callback : function(float), e.g.: `tqdm.update` callback_len : If (default: True) do `callback(len(buffer))`. Otherwise, do `callback(data) for data in buffer.split(delim)`. """ fp_write = fout.write if not delim: while True: tmp = fin.read(buf_size) # flush at EOF if not tmp: getattr(fout, 'flush', lambda: None)() return fp_write(tmp) callback(len(tmp)) # return buf = b'' len_delim = len(delim) # n = 0 while True: tmp = fin.read(buf_size) # flush at EOF if not tmp: if buf: fp_write(buf) if callback_len: # n += 1 + buf.count(delim) callback(1 + buf.count(delim)) else: for i in buf.split(delim): callback(i) getattr(fout, 'flush', lambda: None)() return # n while True: i = tmp.find(delim) if i < 0: buf += tmp break fp_write(buf + tmp[:i + len(delim)]) # n += 1 callback(1 if callback_len else (buf + tmp[:i])) buf = b'' tmp = tmp[i + len_delim:] # ((opt, type), ... ) RE_OPTS = re.compile(r'\n {4}(\S+)\s{2,}:\s*([^,]+)') # better split method assuming no positional args RE_SHLEX = re.compile(r'\s*(? : \2', d) split = RE_OPTS.split(d) opt_types_desc = zip(split[1::3], split[2::3], split[3::3]) d = ''.join(('\n --{0} : {2}{3}' if otd[1] == 'bool' else '\n --{0}=<{1}> : {2}{3}').format( otd[0].replace('_', '-'), otd[0], *otd[1:]) for otd in opt_types_desc if otd[0] not in UNSUPPORTED_OPTS) help_short = "Usage:\n tqdm [--help | options]\n" d = help_short + """ Options: -h, --help Print this help and exit. -v, --version Print version and exit. [truncated — 4594 more characters] ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/uvicorn/server.py ```python import asyncio import functools import logging import os import platform import signal import socket import sys import threading import time from email.utils import formatdate from types import FrameType from typing import TYPE_CHECKING, List, Optional, Sequence, Set, Tuple, Union import click from uvicorn.config import Config if TYPE_CHECKING: from uvicorn.protocols.http.h11_impl import H11Protocol from uvicorn.protocols.http.httptools_impl import HttpToolsProtocol from uvicorn.protocols.websockets.websockets_impl import WebSocketProtocol from uvicorn.protocols.websockets.wsproto_impl import WSProtocol Protocols = Union[H11Protocol, HttpToolsProtocol, WSProtocol, WebSocketProtocol] HANDLED_SIGNALS = ( signal.SIGINT, # Unix signal 2. Sent by Ctrl+C. signal.SIGTERM, # Unix signal 15. Sent by `kill `. ) logger = logging.getLogger("uvicorn.error") class ServerState: """ Shared servers state that is available between all protocol instances. """ def __init__(self) -> None: self.total_requests = 0 self.connections: Set["Protocols"] = set() self.tasks: Set[asyncio.Task] = set() self.default_headers: List[Tuple[bytes, bytes]] = [] class Server: def __init__(self, config: Config) -> None: self.config = config self.server_state = ServerState() self.started = False self.should_exit = False self.force_exit = False self.last_notified = 0.0 def run(self, sockets: Optional[List[socket.socket]] = None) -> None: self.config.setup_event_loop() return asyncio.run(self.serve(sockets=sockets)) async def serve(self, sockets: Optional[List[socket.socket]] = None) -> None: process_id = os.getpid() config = self.config if not config.loaded: config.load() self.lifespan = config.lifespan_class(config) self.install_signal_handlers() message = "Started server process [%d]" color_message = "Started server process [" + click.style("%d", fg="cyan") + "]" logger.info(message, process_id, extra={"color_message": color_message}) await self.startup(sockets=sockets) if self.should_exit: return await self.main_loop() await self.shutdown(sockets=sockets) message = "Finished server process [%d]" color_message = "Finished server process [" + click.style("%d", fg="cyan") + "]" logger.info(message, process_id, extra={"color_message": color_message}) async def startup(self, sockets: list = None) -> None: await self.lifespan.startup() if self.lifespan.should_exit: self.should_exit = True return config = self.config create_protocol = functools.partial( config.http_protocol_class, config=config, server_state=self.server_state ) loop = asyncio.get_running_loop() listeners: Sequence[socket.SocketType] if sockets is not None: # Explicitly passed a list of open sockets. # We use this when the server is run from a Gunicorn worker. def _share_socket( sock: socket.SocketType, ) -> socket.SocketType: # pragma py-linux pragma: py-darwin # Windows requires the socket be explicitly shared across # multiple workers (processes). from socket import fromshare # type: ignore sock_data = sock.share(os.getpid()) # type: ignore return fromshare(sock_data) self.servers = [] for sock in sockets: if config.workers > 1 and platform.system() == "Windows": sock = _share_socket(sock) # pragma py-linux pragma: py-darwin server = await loop.create_server( create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog ) self.servers.append(server) listeners = sockets elif config.fd is not None: # pragma: py-win32 # Use an existing socket, from a file descriptor. sock = socket.fromfd(config.fd, socket.AF_UNIX, socket.SOCK_STREAM) server = await loop.create_server( create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog ) assert server.sockets is not None # mypy listeners = server.sockets self.servers = [server] elif config.uds is not None: # pragma: py-win32 # Create a socket using UNIX domain socket. uds_perms = 0o666 if os.path.exists(config.uds): uds_perms = os.stat(config.uds).st_mode server = await loop.create_unix_server( create_protocol, path=config.uds, ssl=config.ssl, backlog=config.backlog ) os.chmod(config.uds, uds_perms) assert server.sockets is not None # mypy listeners = server.sockets self.servers = [server] else: # Standard case. Create a socket from a host/port pair. try: server = await loop.create_server( create_protocol, host=config.host, port=config.port, ssl=config.ssl, backlog=config.backlog, ) except OSError as exc: logger.error(exc) await self.lifespan.shutdown() sys.exit(1) assert server.sockets is not None listeners = server.sockets self.servers = [server] if sockets is None: self._log_started_message(listeners) else: # We're most likely running multiple workers, so a message has already been # logged by `config.bind_socket()`. pass [truncated — 4977 more characters] ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/watchfiles/main.py ```python import logging import os import sys import warnings from enum import IntEnum from pathlib import Path from typing import TYPE_CHECKING, AsyncGenerator, Callable, Generator, Optional, Set, Tuple, Union import anyio from ._rust_notify import RustNotify from .filters import DefaultFilter __all__ = 'watch', 'awatch', 'Change', 'FileChange' logger = logging.getLogger('watchfiles.main') class Change(IntEnum): """ Enum representing the type of change that occurred. """ added = 1 """A new file or directory was added.""" modified = 2 """A file or directory was modified, can be either a metadata or data change.""" deleted = 3 """A file or directory was deleted.""" def raw_str(self) -> str: return self.name FileChange = Tuple[Change, str] """ A tuple representing a file change, first element is a [`Change`][watchfiles.Change] member, second is the path of the file or directory that changed. """ if TYPE_CHECKING: import asyncio from typing import Protocol import trio AnyEvent = Union[anyio.Event, asyncio.Event, trio.Event] class AbstractEvent(Protocol): def is_set(self) -> bool: ... def watch( *paths: Union[Path, str], watch_filter: Optional[Callable[['Change', str], bool]] = DefaultFilter(), debounce: int = 1_600, step: int = 50, stop_event: Optional['AbstractEvent'] = None, rust_timeout: int = 5_000, yield_on_timeout: bool = False, debug: bool = False, raise_interrupt: bool = True, force_polling: Optional[bool] = None, poll_delay_ms: int = 300, recursive: bool = True, ) -> Generator[Set[FileChange], None, None]: """ Watch one or more paths and yield a set of changes whenever files change. The paths watched can be directories or files, directories are watched recursively - changes in subdirectories are also detected. #### Force polling Notify will fall back to file polling if it can't use file system notifications, but we also force notify to us polling if the `force_polling` argument is `True`; if `force_polling` is unset (or `None`), we enable force polling thus: * if the `WATCHFILES_FORCE_POLLING` environment variable exists and is not empty: * if the value is `false`, `disable` or `disabled`, force polling is disabled * otherwise, force polling is enabled * otherwise, we enable force polling only if we detect we're running on WSL (Windows Subsystem for Linux) Args: *paths: filesystem paths to watch. watch_filter: callable used to filter out changes which are not important, you can either use a raw callable or a [`BaseFilter`][watchfiles.BaseFilter] instance, defaults to an instance of [`DefaultFilter`][watchfiles.DefaultFilter]. To keep all changes, use `None`. debounce: maximum time in milliseconds to group changes over before yielding them. step: time to wait for new changes in milliseconds, if no changes are detected in this time, and at least one change has been detected, the changes are yielded. stop_event: event to stop watching, if this is set, the generator will stop iteration, this can be anything with an `is_set()` method which returns a bool, e.g. `threading.Event()`. rust_timeout: maximum time in milliseconds to wait in the rust code for changes, `0` means no timeout. yield_on_timeout: if `True`, the generator will yield upon timeout in rust even if no changes are detected. debug: whether to print information about all filesystem changes in rust to stdout. raise_interrupt: whether to re-raise `KeyboardInterrupt`s, or suppress the error and just stop iterating. force_polling: See [Force polling](#force-polling) above. poll_delay_ms: delay between polling for changes, only used if `force_polling=True`. recursive: if `True`, watch for changes in sub-directories recursively, otherwise watch only for changes in the top-level directory, default is `True`. Yields: The generator yields sets of [`FileChange`][watchfiles.main.FileChange]s. ```py title="Example of watch usage" from watchfiles import watch for changes in watch('./first/dir', './second/dir', raise_interrupt=False): print(changes) ``` """ force_polling = _default_force_polling(force_polling) with RustNotify([str(p) for p in paths], debug, force_polling, poll_delay_ms, recursive) as watcher: while True: raw_changes = watcher.watch(debounce, step, rust_timeout, stop_event) if raw_changes == 'timeout': if yield_on_timeout: yield set() else: logger.debug('rust notify timeout, continuing') elif raw_changes == 'signal': if raise_interrupt: raise KeyboardInterrupt else: logger.warning('KeyboardInterrupt caught, stopping watch') return elif raw_changes == 'stop': return else: changes = _prep_changes(raw_changes, watch_filter) if changes: _log_changes(changes) yield changes async def awatch( # noqa C901 *paths: Union[Path, str], watch_filter: Optional[Callable[[Change, str], bool]] = DefaultFilter(), debounce: int = 1_600, step: int = 50, stop_event: Optional['AnyEvent'] = None, rust_timeout: Optional[int] = None, yield_on_timeout: bool = False, debug: bool = False, raise_interrupt: Optional[bool] = None, force_polling: Optional[bool] = None, poll_delay_ms: int = 300, recursive: bool = True, ) -> AsyncGenerator[Set[FileChange], None]: """ Asynchronous equivalent of [`watch`][watchfiles.watch] using threads to wait for changes. Arguments match those o [truncated — 6729 more characters] ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/markdown_it/main.py ```python from __future__ import annotations from collections.abc import Callable, Generator, Iterable, Mapping, MutableMapping from contextlib import contextmanager from typing import Any, Literal, overload from . import helpers, presets from .common import normalize_url, utils from .parser_block import ParserBlock from .parser_core import ParserCore from .parser_inline import ParserInline from .renderer import RendererHTML, RendererProtocol from .rules_core.state_core import StateCore from .token import Token from .utils import EnvType, OptionsDict, OptionsType, PresetType try: import linkify_it except ModuleNotFoundError: linkify_it = None _PRESETS: dict[str, PresetType] = { "default": presets.default.make(), "js-default": presets.js_default.make(), "zero": presets.zero.make(), "commonmark": presets.commonmark.make(), "gfm-like": presets.gfm_like.make(), } class MarkdownIt: def __init__( self, config: str | PresetType = "commonmark", options_update: Mapping[str, Any] | None = None, *, renderer_cls: Callable[[MarkdownIt], RendererProtocol] = RendererHTML, ): """Main parser class :param config: name of configuration to load or a pre-defined dictionary :param options_update: dictionary that will be merged into ``config["options"]`` :param renderer_cls: the class to load as the renderer: ``self.renderer = renderer_cls(self) """ # add modules self.utils = utils self.helpers = helpers # initialise classes self.inline = ParserInline() self.block = ParserBlock() self.core = ParserCore() self.renderer = renderer_cls(self) self.linkify = linkify_it.LinkifyIt() if linkify_it else None # set the configuration if options_update and not isinstance(options_update, Mapping): # catch signature change where renderer_cls was not used as a key-word raise TypeError( f"options_update should be a mapping: {options_update}" "\n(Perhaps you intended this to be the renderer_cls?)" ) self.configure(config, options_update=options_update) def __repr__(self) -> str: return f"{self.__class__.__module__}.{self.__class__.__name__}()" @overload def __getitem__(self, name: Literal["inline"]) -> ParserInline: ... @overload def __getitem__(self, name: Literal["block"]) -> ParserBlock: ... @overload def __getitem__(self, name: Literal["core"]) -> ParserCore: ... @overload def __getitem__(self, name: Literal["renderer"]) -> RendererProtocol: ... @overload def __getitem__(self, name: str) -> Any: ... def __getitem__(self, name: str) -> Any: return { "inline": self.inline, "block": self.block, "core": self.core, "renderer": self.renderer, }[name] def set(self, options: OptionsType) -> None: """Set parser options (in the same format as in constructor). Probably, you will never need it, but you can change options after constructor call. __Note:__ To achieve the best possible performance, don't modify a `markdown-it` instance options on the fly. If you need multiple configurations it's best to create multiple instances and initialize each with separate config. """ self.options = OptionsDict(options) def configure( self, presets: str | PresetType, options_update: Mapping[str, Any] | None = None ) -> MarkdownIt: """Batch load of all options and component settings. This is an internal method, and you probably will not need it. But if you will - see available presets and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets) We strongly recommend to use presets instead of direct config loads. That will give better compatibility with next versions. """ if isinstance(presets, str): if presets not in _PRESETS: raise KeyError(f"Wrong `markdown-it` preset '{presets}', check name") config = _PRESETS[presets] else: config = presets if not config: raise ValueError("Wrong `markdown-it` config, can't be empty") options = config.get("options", {}) or {} if options_update: options = {**options, **options_update} # type: ignore self.set(options) # type: ignore if "components" in config: for name, component in config["components"].items(): rules = component.get("rules", None) if rules: self[name].ruler.enableOnly(rules) rules2 = component.get("rules2", None) if rules2: self[name].ruler2.enableOnly(rules2) return self def get_all_rules(self) -> dict[str, list[str]]: """Return the names of all active rules.""" rules = { chain: self[chain].ruler.get_all_rules() for chain in ["core", "block", "inline"] } rules["inline2"] = self.inline.ruler2.get_all_rules() return rules def get_active_rules(self) -> dict[str, list[str]]: """Return the names of all active rules.""" rules = { chain: self[chain].ruler.get_active_rules() for chain in ["core", "block", "inline"] } rules["inline2"] = self.inline.ruler2.get_active_rules() return rules def enable( self, names: str | Iterable[str], ignoreInvalid: bool = False ) -> MarkdownIt: """Enable list or rules. (chainable) :param names: rule name or list of rule names to enable. :param ignoreInvalid: set `true` to ignore errors when rule not found. It will a [truncated — 6772 more characters] ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/pip/_internal/main.py ```python from typing import List, Optional def main(args: Optional[List[str]] = None) -> int: """This is preserved for old console scripts that may still be referencing it. For additional details, see https://github.com/pypa/pip/issues/7498. """ from pip._internal.utils.entrypoints import _wrapper return _wrapper(args) ``` ### calhacks1/calhacks1.env/lib/python3.11/site-packages/together/cli/cli.py ```python #! python import argparse import together from together.commands import chat, complete, files, finetune, image, models from together.utils import get_logger logger = get_logger(str(__name__)) def main() -> None: parser = argparse.ArgumentParser( description="Together CLI", prog="together", ) parser.add_argument( "-V", "--version", action="version", version="%(prog)s " + together.version, ) parser.add_argument( "--endpoint", "-e", help="[Optional] Together API Endpoint URL", type=str, required=False, default=None, ) parser.add_argument( "--verbose", "-v", default=together.log_level, choices=["CRITICAL", "ERROR", "WARNING", "SUCCESS", "INFO", "DEBUG", "TRACE"], type=str, help="Set logging level. Defaults to WARNING. DEBUG will show all logs.", required=False, ) subparser = parser.add_subparsers(dest="base") models.add_parser(subparser) chat.add_parser(subparser) complete.add_parser(subparser) image.add_parser(subparser) files.add_parser(subparser) finetune.add_parser(subparser) args = parser.parse_args() # Setup logging together.log_level = args.verbose try: args.func(args) except AttributeError as e: # print error, but ignore if `together` is run. if str(e) != "'Namespace' object has no attribute 'func'": raise together.AttributeError(e) parser.print_help() if __name__ == "__main__": main() ``` [2615 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]