toggle(i)}>
{r.patient_full_name || 'Unnamed'}
{r.patient_age && {r.patient_age}y}
{r.patient_sex && • {r.patient_sex}}
{r.incident_location && (
[truncated — 3037 more characters]
```
### first_responder_env/lib/python3.12/site-packages/rsa/cli.py
```python
# Copyright 2011 Sybren A. Stüvel
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Commandline scripts.
These scripts are called by the executables defined in setup.py.
"""
import abc
import sys
import typing
import optparse
import rsa
import rsa.key
import rsa.pkcs1
HASH_METHODS = sorted(rsa.pkcs1.HASH_METHODS.keys())
Indexable = typing.Union[typing.Tuple, typing.List[str]]
def keygen() -> None:
"""Key generator."""
# Parse the CLI options
parser = optparse.OptionParser(
usage="usage: %prog [options] keysize",
description='Generates a new RSA key pair of "keysize" bits.',
)
parser.add_option(
"--pubout",
type="string",
help="Output filename for the public key. The public key is "
"not saved if this option is not present. You can use "
"pyrsa-priv2pub to create the public key file later.",
)
parser.add_option(
"-o",
"--out",
type="string",
help="Output filename for the private key. The key is "
"written to stdout if this option is not present.",
)
parser.add_option(
"--form",
help="key format of the private and public keys - default PEM",
choices=("PEM", "DER"),
default="PEM",
)
(cli, cli_args) = parser.parse_args(sys.argv[1:])
if len(cli_args) != 1:
parser.print_help()
raise SystemExit(1)
try:
keysize = int(cli_args[0])
except ValueError as ex:
parser.print_help()
print("Not a valid number: %s" % cli_args[0], file=sys.stderr)
raise SystemExit(1) from ex
print("Generating %i-bit key" % keysize, file=sys.stderr)
(pub_key, priv_key) = rsa.newkeys(keysize)
# Save public key
if cli.pubout:
print("Writing public key to %s" % cli.pubout, file=sys.stderr)
data = pub_key.save_pkcs1(format=cli.form)
with open(cli.pubout, "wb") as outfile:
outfile.write(data)
# Save private key
data = priv_key.save_pkcs1(format=cli.form)
if cli.out:
print("Writing private key to %s" % cli.out, file=sys.stderr)
with open(cli.out, "wb") as outfile:
outfile.write(data)
else:
print("Writing private key to stdout", file=sys.stderr)
sys.stdout.buffer.write(data)
class CryptoOperation(metaclass=abc.ABCMeta):
"""CLI callable that operates with input, output, and a key."""
keyname = "public" # or 'private'
usage = "usage: %%prog [options] %(keyname)s_key"
description = ""
operation = "decrypt"
operation_past = "decrypted"
operation_progressive = "decrypting"
input_help = "Name of the file to %(operation)s. Reads from stdin if " "not specified."
output_help = (
"Name of the file to write the %(operation_past)s file "
"to. Written to stdout if this option is not present."
)
expected_cli_args = 1
has_output = True
key_class = rsa.PublicKey # type: typing.Type[rsa.key.AbstractKey]
def __init__(self) -> None:
self.usage = self.usage % self.__class__.__dict__
self.input_help = self.input_help % self.__class__.__dict__
self.output_help = self.output_help % self.__class__.__dict__
@abc.abstractmethod
def perform_operation(
self, indata: bytes, key: rsa.key.AbstractKey, cli_args: Indexable
) -> typing.Any:
"""Performs the program's operation.
Implement in a subclass.
:returns: the data to write to the output.
"""
def __call__(self) -> None:
"""Runs the program."""
(cli, cli_args) = self.parse_cli()
key = self.read_key(cli_args[0], cli.keyform)
indata = self.read_infile(cli.input)
print(self.operation_progressive.title(), file=sys.stderr)
outdata = self.perform_operation(indata, key, cli_args)
if self.has_output:
self.write_outfile(outdata, cli.output)
def parse_cli(self) -> typing.Tuple[optparse.Values, typing.List[str]]:
"""Parse the CLI options
:returns: (cli_opts, cli_args)
"""
parser = optparse.OptionParser(usage=self.usage, description=self.description)
parser.add_option("-i", "--input", type="string", help=self.input_help)
if self.has_output:
parser.add_option("-o", "--output", type="string", help=self.output_help)
parser.add_option(
"--keyform",
help="Key format of the %s key - default PEM" % self.keyname,
choices=("PEM", "DER"),
default="PEM",
)
(cli, cli_args) = parser.parse_args(sys.argv[1:])
if len(cli_args) != self.expected_cli_args:
parser.print_help()
raise SystemExit(1)
return cli, cli_args
def read_key(self, filename: str, keyform: str) -> rsa.key.AbstractKey:
"""Reads a public or private key."""
print("Reading %s key from %s" % (self.keyname, filename), file=sys.stderr)
with open(filename, "rb") as keyfile:
keydata = keyfile.read()
return self.key_class.load_pkcs1(keydata, keyform)
def read_infile(self, inname: str) -> bytes:
"""Read the input file"""
if inname:
print("Reading input from %s" % inname, file=sys.stderr)
with open(inname, "rb") as infile:
return infile.read()
print("Reading input from stdin", f
[truncated — 3861 more characters]
```
### first_responder_env/lib/python3.12/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 textwrap import indent
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(f"{val} : {typ}")
# sys.stderr.write('\ndebug | `val:type`: `' + val + ':' + typ + '`.\n')
if typ == 'bool':
if (val == 'True') or (val == ''):
return True
if val == 'False':
return False
raise TqdmTypeError(val + ' : ' + typ)
if typ == 'chr':
if len(val) == 1:
return val.encode()
if re.match(r"^\\\w+$", val):
return eval(f'"{val}"').encode()
raise TqdmTypeError(f"{val} : {typ}")
if typ == 'str':
return val
if typ == 'int':
try:
return int(val)
except ValueError as exc:
raise TqdmTypeError(f"{val} : {typ}") from exc
if typ == 'float':
try:
return float(val)
except ValueError as exc:
raise TqdmTypeError(f"{val} : {typ}") from exc
raise TqdmTypeError(f"{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(
[truncated — 5010 more characters]
```
[2831 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]