Pretty-print a project's module tree

Navigation

Verified details

These details have been verified by PyPI
Project links
GitHub Statistics
Maintainers
Avatar for yberreby from gravatar.com yberreby

Unverified details

These details have not been verified by PyPI
Meta
Classifiers
Report project as malware

Project description

pypatree

CI PyPI Python License

Pretty-print a project's module tree with syntax-highlighted signatures.

uv add --dev pypatree
uv run pypatree

pypatree  pypatree - Pretty-print a project's module tree.
├── __main__
│   ├── main() -> None
│   └── run(cfg: pypatree.config.Config) -> None
├── config  Configuration types for pypatree.
│   ├── Config(exclude: Optional[str] = '^test$|^test_', docstrings: 
│   │   pypatree.config.DocstringMode = <DocstringMode.short: 'short'>) -> None
│   └── DocstringMode(*args, **kwargs)
├── discovery
│   └── get_packages(exclude: Optional[str] = None) -> dict[str, list[str]]
├── display
│   ├── print_tree(pkg_name: str, tree: dict[str, typing.Any], cfg: 
│   │   pypatree.config.Config) -> None
│   └── render_tree(tree: dict[str, typing.Any], prefix: str = '') -> list[str]
├── introspection
│   ├── format_signature(obj: Union[Callable, type]) -> str
│   ├── get_module_docstring(modname: str, short: bool = True) -> Optional[str]
│   └── get_module_items(modname: str, exclude: Optional[str] = None) -> 
│       list[str]
└── tree
    └── build_tree(submods: list[str], pkg_name: str, exclude: Optional[str] = 
        None) -> dict[str, typing.Any]

Run pypatree --help for options:

usage: pypatree [-h] [--exclude {None}|STR] [--docstrings {none,short,full}]

Display module tree with public functions/classes.

╭─ options ──────────────────────────────────────────────────────────────────╮
│ -h, --help              show this help message and exit                    │
│ --exclude {None}|STR    Regex to exclude module segments (default: test    │
│                         modules). Use '' for none. (default:               │
│                         '^test$|^test_')                                   │
│ --docstrings {none,short,full}                                             │
│                         Show module docstrings: none, short (first line),  │
│                         or full. (default: short)                          │
╰────────────────────────────────────────────────────────────────────────────╯

Example on httpx:

httpx
├── ASGITransport(app: '_ASGIApp', raise_app_exceptions: 'bool' = True, 
│   root_path: 'str' = '', client: 'tuple[str, int]' = ('127.0.0.1', 123)) -> 
│   'None'
├── AsyncBaseTransport(*args, **kwargs)
├── AsyncByteStream(*args, **kwargs)
├── AsyncClient(*, auth: 'AuthTypes | None' = None, params: 'QueryParamTypes | 
│   None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | 
│   None' = None, verify: 'ssl.SSLContext | str | bool' = True, cert: 'CertTypes
│   | None' = None, http1: 'bool' = True, http2: 'bool' = False, proxy: 
│   'ProxyTypes | None' = None, mounts: 'None | typing.Mapping[str, 
│   AsyncBaseTransport | None]' = None, timeout: 'TimeoutTypes' = 
│   Timeout(timeout=5.0), follow_redirects: 'bool' = False, limits: 'Limits' = 
│   Limits(max_connections=100, max_keepalive_connections=20, 
│   keepalive_expiry=5.0), max_redirects: 'int' = 20, event_hooks: 'None | 
│   typing.Mapping[str, list[EventHook]]' = None, base_url: 'URL | str' = '', 
│   transport: 'AsyncBaseTransport | None' = None, trust_env: 'bool' = True, 
│   default_encoding: 'str | typing.Callable[[bytes], str]' = 'utf-8') -> 'None'
├── AsyncHTTPTransport(verify: 'ssl.SSLContext | str | bool' = True, cert: 
│   'CertTypes | None' = None, trust_env: 'bool' = True, http1: 'bool' = True, 
│   http2: 'bool' = False, limits: 'Limits' = Limits(max_connections=100, 
│   max_keepalive_connections=20, keepalive_expiry=5.0), proxy: 'ProxyTypes | 
│   None' = None, uds: 'str | None' = None, local_address: 'str | None' = None, 
│   retries: 'int' = 0, socket_options: 'typing.Iterable[SOCKET_OPTION] | None' 
│   = None) -> 'None'
├── Auth(*args, **kwargs)
├── BaseTransport(*args, **kwargs)
├── BasicAuth(username: 'str | bytes', password: 'str | bytes') -> 'None'
├── ByteStream(stream: 'bytes') -> 'None'
├── Client(*, auth: 'AuthTypes | None' = None, params: 'QueryParamTypes | None' 
│   = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' 
│   = None, verify: 'ssl.SSLContext | str | bool' = True, cert: 'CertTypes | 
│   None' = None, trust_env: 'bool' = True, http1: 'bool' = True, http2: 'bool' 
│   = False, proxy: 'ProxyTypes | None' = None, mounts: 'None | 
│   typing.Mapping[str, BaseTransport | None]' = None, timeout: 'TimeoutTypes' =
│   Timeout(timeout=5.0), follow_redirects: 'bool' = False, limits: 'Limits' = 
│   Limits(max_connections=100, max_keepalive_connections=20, 
│   keepalive_expiry=5.0), max_redirects: 'int' = 20, event_hooks: 'None | 
│   typing.Mapping[str, list[EventHook]]' = None, base_url: 'URL | str' = '', 
│   transport: 'BaseTransport | None' = None, default_encoding: 'str | 
│   typing.Callable[[bytes], str]' = 'utf-8') -> 'None'
├── CloseError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── ConnectError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── ConnectTimeout(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── CookieConflict(message: 'str') -> 'None'
├── Cookies(cookies: 'CookieTypes | None' = None) -> 'None'
├── DecodingError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── DigestAuth(username: 'str | bytes', password: 'str | bytes') -> 'None'
├── HTTPError(message: 'str') -> 'None'
├── HTTPStatusError(message: 'str', *, request: 'Request', response: 'Response')
│   -> 'None'
├── HTTPTransport(verify: 'ssl.SSLContext | str | bool' = True, cert: 'CertTypes
│   | None' = None, trust_env: 'bool' = True, http1: 'bool' = True, http2: 
│   'bool' = False, limits: 'Limits' = Limits(max_connections=100, 
│   max_keepalive_connections=20, keepalive_expiry=5.0), proxy: 'ProxyTypes | 
│   None' = None, uds: 'str | None' = None, local_address: 'str | None' = None, 
│   retries: 'int' = 0, socket_options: 'typing.Iterable[SOCKET_OPTION] | None' 
│   = None) -> 'None'
├── Headers(headers: 'HeaderTypes | None' = None, encoding: 'str | None' = None)
│   -> 'None'
├── InvalidURL(message: 'str') -> 'None'
├── Limits(*, max_connections: 'int | None' = None, max_keepalive_connections: 
│   'int | None' = None, keepalive_expiry: 'float | None' = 5.0) -> 'None'
├── LocalProtocolError(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── MockTransport(handler: 'SyncHandler | AsyncHandler') -> 'None'
├── NetRCAuth(file: 'str | None' = None) -> 'None'
├── NetworkError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── PoolTimeout(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── ProtocolError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── Proxy(url: 'URL | str', *, ssl_context: 'ssl.SSLContext | None' = None, 
│   auth: 'tuple[str, str] | None' = None, headers: 'HeaderTypes | None' = None)
│   -> 'None'
├── ProxyError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── QueryParams(*args: 'QueryParamTypes | None', **kwargs: 'typing.Any') -> 
│   'None'
├── ReadError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── ReadTimeout(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── RemoteProtocolError(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── Request(method: 'str', url: 'URL | str', *, params: 'QueryParamTypes | None'
│   = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' 
│   = None, content: 'RequestContent | None' = None, data: 'RequestData | None' 
│   = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = 
│   None, stream: 'SyncByteStream | AsyncByteStream | None' = None, extensions: 
│   'RequestExtensions | None' = None) -> 'None'
├── RequestError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── RequestNotRead() -> 'None'
├── Response(status_code: 'int', *, headers: 'HeaderTypes | None' = None, 
│   content: 'ResponseContent | None' = None, text: 'str | None' = None, html: 
│   'str | None' = None, json: 'typing.Any' = None, stream: 'SyncByteStream | 
│   AsyncByteStream | None' = None, request: 'Request | None' = None, 
│   extensions: 'ResponseExtensions | None' = None, history: 'list[Response] | 
│   None' = None, default_encoding: 'str | typing.Callable[[bytes], str]' = 
│   'utf-8') -> 'None'
├── ResponseNotRead() -> 'None'
├── StreamClosed() -> 'None'
├── StreamConsumed() -> 'None'
├── StreamError(message: 'str') -> 'None'
├── SyncByteStream(*args, **kwargs)
├── Timeout(timeout: 'TimeoutTypes | UnsetType' = <httpx._config.UnsetType 
│   object>, *, connect: 'None | float | UnsetType' = <httpx._config.UnsetType 
│   object>, read: 'None | float | UnsetType' = <httpx._config.UnsetType 
│   object>, write: 'None | float | UnsetType' = <httpx._config.UnsetType 
│   object>, pool: 'None | float | UnsetType' = <httpx._config.UnsetType 
│   object>) -> 'None'
├── TimeoutException(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── TooManyRedirects(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── TransportError(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── URL(url: 'URL | str' = '', **kwargs: 'typing.Any') -> 'None'
├── UnsupportedProtocol(message: 'str', *, request: 'Request | None' = None) -> 
│   'None'
├── WSGITransport(app: 'WSGIApplication', raise_app_exceptions: 'bool' = True, 
│   script_name: 'str' = '', remote_addr: 'str' = '127.0.0.1', wsgi_errors: 
│   'typing.TextIO | None' = None) -> 'None'
├── WriteError(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── WriteTimeout(message: 'str', *, request: 'Request | None' = None) -> 'None'
├── codes(*args, **kwargs)
├── create_ssl_context(verify: 'ssl.SSLContext | str | bool' = True, cert: 
│   'CertTypes | None' = None, trust_env: 'bool' = True) -> 'ssl.SSLContext'
├── delete(url: 'URL | str', *, params: 'QueryParamTypes | None' = None, 
│   headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, 
│   auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, timeout: 'TimeoutTypes' = 
│   Timeout(timeout=5.0), verify: 'ssl.SSLContext | str | bool' = True, 
│   trust_env: 'bool' = True) -> 'Response'
├── get(url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 
│   'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 
│   'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, verify: 'ssl.SSLContext | str | bool' = 
│   True, timeout: 'TimeoutTypes' = Timeout(timeout=5.0), trust_env: 'bool' = 
│   True) -> 'Response'
├── head(url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 
│   'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 
│   'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, verify: 'ssl.SSLContext | str | bool' = 
│   True, timeout: 'TimeoutTypes' = Timeout(timeout=5.0), trust_env: 'bool' = 
│   True) -> 'Response'
├── main() -> None
├── options(url: 'URL | str', *, params: 'QueryParamTypes | None' = None, 
│   headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, 
│   auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, verify: 'ssl.SSLContext | str | bool' = 
│   True, timeout: 'TimeoutTypes' = Timeout(timeout=5.0), trust_env: 'bool' = 
│   True) -> 'Response'
├── patch(url: 'URL | str', *, content: 'RequestContent | None' = None, data: 
│   'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 
│   'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, 
│   headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, 
│   auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, verify: 'ssl.SSLContext | str | bool' = 
│   True, timeout: 'TimeoutTypes' = Timeout(timeout=5.0), trust_env: 'bool' = 
│   True) -> 'Response'
├── post(url: 'URL | str', *, content: 'RequestContent | None' = None, data: 
│   'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 
│   'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, 
│   headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, 
│   auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, verify: 'ssl.SSLContext | str | bool' = 
│   True, timeout: 'TimeoutTypes' = Timeout(timeout=5.0), trust_env: 'bool' = 
│   True) -> 'Response'
├── put(url: 'URL | str', *, content: 'RequestContent | None' = None, data: 
│   'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 
│   'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, 
│   headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, 
│   auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   follow_redirects: 'bool' = False, verify: 'ssl.SSLContext | str | bool' = 
│   True, timeout: 'TimeoutTypes' = Timeout(timeout=5.0), trust_env: 'bool' = 
│   True) -> 'Response'
├── request(method: 'str', url: 'URL | str', *, params: 'QueryParamTypes | None'
│   = None, content: 'RequestContent | None' = None, data: 'RequestData | None' 
│   = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = 
│   None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = 
│   None, auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   timeout: 'TimeoutTypes' = Timeout(timeout=5.0), follow_redirects: 'bool' = 
│   False, verify: 'ssl.SSLContext | str | bool' = True, trust_env: 'bool' = 
│   True) -> 'Response'
├── stream(method: 'str', url: 'URL | str', *, params: 'QueryParamTypes | None' 
│   = None, content: 'RequestContent | None' = None, data: 'RequestData | None' 
│   = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = 
│   None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = 
│   None, auth: 'AuthTypes | None' = None, proxy: 'ProxyTypes | None' = None, 
│   timeout: 'TimeoutTypes' = Timeout(timeout=5.0), follow_redirects: 'bool' = 
│   False, verify: 'ssl.SSLContext | str | bool' = True, trust_env: 'bool' = 
│   True) -> 'typing.Iterator[Response]'
├── __version__
├── _api
├── _auth
│   └── FunctionAuth(func: 'typing.Callable[[Request], Request]') -> 'None'
├── _client
│   ├── BaseClient(*, auth: 'AuthTypes | None' = None, params: 'QueryParamTypes 
│   │   | None' = None, headers: 'HeaderTypes | None' = None, cookies: 
│   │   'CookieTypes | None' = None, timeout: 'TimeoutTypes' = 
│   │   Timeout(timeout=5.0), follow_redirects: 'bool' = False, max_redirects: 
│   │   'int' = 20, event_hooks: 'None | typing.Mapping[str, list[EventHook]]' =
│   │   None, base_url: 'URL | str' = '', trust_env: 'bool' = True, 
│   │   default_encoding: 'str | typing.Callable[[bytes], str]' = 'utf-8') -> 
│   │   'None'
│   ├── BoundAsyncStream(stream: 'AsyncByteStream', response: 'Response', start:
│   │   'float') -> 'None'
│   ├── BoundSyncStream(stream: 'SyncByteStream', response: 'Response', start: 
│   │   'float') -> 'None'
│   ├── ClientState(*args, **kwargs)
│   └── UseClientDefault(*args, **kwargs)
├── _config
│   └── UnsetType(*args, **kwargs)
├── _content
│   ├── AsyncIteratorByteStream(stream: 'AsyncIterable[bytes]') -> 'None'
│   ├── IteratorByteStream(stream: 'Iterable[bytes]') -> 'None'
│   ├── UnattachedStream(*args, **kwargs)
│   ├── encode_content(content: 'str | bytes | Iterable[bytes] | 
│   │   AsyncIterable[bytes]') -> 'tuple[dict[str, str], SyncByteStream | 
│   │   AsyncByteStream]'
│   ├── encode_html(html: 'str') -> 'tuple[dict[str, str], ByteStream]'
│   ├── encode_json(json: 'Any') -> 'tuple[dict[str, str], ByteStream]'
│   ├── encode_multipart_data(data: 'RequestData', files: 'RequestFiles', 
│   │   boundary: 'bytes | None') -> 'tuple[dict[str, str], MultipartStream]'
│   ├── encode_request(content: 'RequestContent | None' = None, data: 
│   │   'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 
│   │   'Any | None' = None, boundary: 'bytes | None' = None) -> 
│   │   'tuple[dict[str, str], SyncByteStream | AsyncByteStream]'
│   ├── encode_response(content: 'ResponseContent | None' = None, text: 'str | 
│   │   None' = None, html: 'str | None' = None, json: 'Any | None' = None) -> 
│   │   'tuple[dict[str, str], SyncByteStream | AsyncByteStream]'
│   ├── encode_text(text: 'str') -> 'tuple[dict[str, str], ByteStream]'
│   └── encode_urlencoded_data(data: 'RequestData') -> 'tuple[dict[str, str], 
│       ByteStream]'
├── _decoders  Handlers for Content-Encoding.
│   ├── BrotliDecoder() -> 'None'
│   ├── ByteChunker(chunk_size: 'int | None' = None) -> 'None'
│   ├── ContentDecoder(*args, **kwargs)
│   ├── DeflateDecoder() -> 'None'
│   ├── GZipDecoder() -> 'None'
│   ├── IdentityDecoder(*args, **kwargs)
│   ├── LineDecoder() -> 'None'
│   ├── MultiDecoder(children: 'typing.Sequence[ContentDecoder]') -> 'None'
│   ├── TextChunker(chunk_size: 'int | None' = None) -> 'None'
│   ├── TextDecoder(encoding: 'str' = 'utf-8') -> 'None'
│   └── ZStandardDecoder() -> 'None'
├── _exceptions  Our exception hierarchy:
│   └── request_context(request: 'Request | None' = None) -> 
│       'typing.Iterator[None]'
├── _main
├── _models
├── _multipart
│   ├── DataField(name: 'str', value: 'str | bytes | int | float | None') -> 
│   │   'None'
│   ├── FileField(name: 'str', value: 'FileTypes') -> 'None'
│   ├── MultipartStream(data: 'RequestData', files: 'RequestFiles', boundary: 
│   │   'bytes | None' = None) -> 'None'
│   └── get_multipart_boundary_from_content_type(content_type: 'bytes | None') 
│       -> 'bytes | None'
├── _status_codes
├── _transports
│   ├── asgi
│   │   ├── ASGIResponseStream(body: 'list[bytes]') -> 'None'
│   │   ├── create_event() -> 'Event'
│   │   └── is_running_trio() -> 'bool'
│   ├── base
│   ├── default  Custom transports, with nicely configured defaults.
│   │   ├── AsyncResponseStream(httpcore_stream: 'typing.AsyncIterable[bytes]') 
│   │   │   -> 'None'
│   │   ├── ResponseStream(httpcore_stream: 'typing.Iterable[bytes]') -> 'None'
│   │   └── map_httpcore_exceptions() -> 'typing.Iterator[None]'
│   ├── mock
│   └── wsgi
│       └── WSGIByteStream(result: 'typing.Iterable[bytes]') -> 'None'
├── _types  Type definitions for type checking purposes.
├── _urlparse  An implementation of `urlparse` that provides URL validation and 
│   normalization
│   ├── PERCENT(string: 'str') -> 'str'
│   ├── ParseResult(*args, **kwargs)
│   ├── encode_host(host: 'str') -> 'str'
│   ├── normalize_path(path: 'str') -> 'str'
│   ├── normalize_port(port: 'str | int | None', scheme: 'str') -> 'int | None'
│   ├── percent_encoded(string: 'str', safe: 'str') -> 'str'
│   ├── quote(string: 'str', safe: 'str') -> 'str'
│   ├── urlparse(url: 'str' = '', **kwargs: 'str | None') -> 'ParseResult'
│   └── validate_path(path: 'str', has_scheme: 'bool', has_authority: 'bool') ->
│       'None'
├── _urls
└── _utils
    ├── URLPattern(pattern: 'str') -> 'None'
    ├── get_environment_proxies() -> 'dict[str, str | None]'
    ├── is_ipv4_hostname(hostname: 'str') -> 'bool'
    ├── is_ipv6_hostname(hostname: 'str') -> 'bool'
    ├── peek_filelike_length(stream: 'typing.Any') -> 'int | None'
    ├── primitive_value_to_str(value: 'PrimitiveData') -> 'str'
    ├── to_bytes(value: 'str | bytes', encoding: 'str' = 'utf-8') -> 'bytes'
    ├── to_bytes_or_str(value: 'str', match_type_of: 'typing.AnyStr') -> 
    │   'typing.AnyStr'
    ├── to_str(value: 'str | bytes', encoding: 'str' = 'utf-8') -> 'str'
    └── unquote(value: 'str') -> 'str'

Project details

Verified details

These details have been verified by PyPI
Project links
GitHub Statistics
Maintainers
Avatar for yberreby from gravatar.com yberreby

Unverified details

These details have not been verified by PyPI
Meta
Classifiers

Release history Release notifications | RSS feed

0.4.0

0.3.0

0.2.1

This version

0.2.0

0.1.0

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

pypatree-0.2.0.tar.gz (71.1 kB view details)

Uploaded Source

Built Distribution

If you're not sure about the file name format, learn more about wheel file names.

pypatree-0.2.0-py3-none-any.whl (14.7 kB view details)

Uploaded Python 3

File details

Details for the file pypatree-0.2.0.tar.gz.

File metadata

  • Download URL: pypatree-0.2.0.tar.gz
  • Upload date:
  • Size: 71.1 kB
  • Tags: Source
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: uv/0.9.15 {"installer":{"name":"uv","version":"0.9.15","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

File hashes

Hashes for pypatree-0.2.0.tar.gz
Algorithm Hash digest
SHA256 f99616e5d7853619e209099b914833c3247afa3c8cdd73b7cebbd30e3c82bb36
MD5 cde16e6c7c1ad7da4bf9b52a449e7b78
BLAKE2b-256 bb5056322f8d528c54aa778b288026e571f81c32287d51f5fca24e8a0d68cff3

See more details on using hashes here.

File details

Details for the file pypatree-0.2.0-py3-none-any.whl.

File metadata

  • Download URL: pypatree-0.2.0-py3-none-any.whl
  • Upload date:
  • Size: 14.7 kB
  • Tags: Python 3
  • Uploaded using Trusted Publishing? Yes
  • Uploaded via: uv/0.9.15 {"installer":{"name":"uv","version":"0.9.15","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

File hashes

Hashes for pypatree-0.2.0-py3-none-any.whl
Algorithm Hash digest
SHA256 95ded3cef54fd577f7d1f8064090615a2aa7c9b96e577384f1d58bc6ddd4318e
MD5 6fb277aec58092c2f02e687a62a18df3
BLAKE2b-256 1a7fc00574804df721394f9ad95f6bfb5e041dbdcbd5c04bfd657bd579fa11eb

See more details on using hashes here.

Supported by

AWS Cloud computing and Security Sponsor Datadog Monitoring Depot Continuous Integration Fastly CDN Google Download Analytics Pingdom Monitoring Sentry Error logging StatusPage Status page