streamlit-float API Reference
Full documentation for streamlit-float (Standard Library / Native)
streamlit-float.components
Python Library Documentation: package streamlit.components.v1 in streamlit.components
NAME
streamlit.components.v1 - Contains the files and modules for the exposed API.
PACKAGE CONTENTS
component_arrow
component_registry
components
custom_component
FUNCTIONS
declare_component(name: 'str', path: 'str | Path | None' = None, url: 'str | None' = None) -> 'CustomComponent'
Create a custom component and register it if there is a ``ScriptRunContext``.
The component is not registered when there is no ``ScriptRunContext``.
This can happen when a ``CustomComponent`` is executed as standalone
command (e.g. for testing).
To use this function, import it from the ``streamlit.components.v1``
module.
.. warning::
Using ``st.components.v1.declare_component`` directly (instead of
importing its module) is deprecated and will be disallowed in a later
version.
Parameters
----------
name : str
A short, descriptive name for the component, like "slider".
path: str, Path, or None
The path to serve the component's frontend files from. The path should
be absolute. If ``path`` is ``None`` (default), Streamlit will serve
the component from the location in ``url``. Either ``path`` or ``url``
must be specified. If both are specified, then ``url`` will take
precedence.
url: str or None
The URL that the component is served from. If ``url`` is ``None``
(default), Streamlit will serve the component from the location in
``path``. Either ``path`` or ``url`` must be specified. If both are
specified, then ``url`` will take precedence.
Returns
-------
CustomComponent
A ``CustomComponent`` that can be called like a function.
Calling the component will create a new instance of the component
in the Streamlit app.
html = components.v1.html(self, html: 'str', width: 'int | None' = None, height: 'int | None' = None, scrolling: 'bool' = False, *, tab_index: 'int | None' = None) -> 'DeltaGenerator'
Display an HTML string in an iframe.
To use this function, import it from the ``streamlit.components.v1``
module.
If you want to insert HTML text into your app without an iframe, try
``st.html`` instead.
.. deprecated::
``st.components.v1.html`` is deprecated and will be removed in a
future release. Please use ``st.iframe`` instead, which provides
the same functionality with additional features like automatic
content sizing and local file support.
.. warning::
Using ``st.components.v1.html`` directly (instead of importing
its module) is deprecated and will be disallowed in a later version.
Parameters
----------
html : str
The HTML string to embed in the iframe.
width : int
The width of the iframe in CSS pixels. By default, this is the
app's default element width.
height : int
The height of the frame in CSS pixels. By default, this is ``150``.
scrolling : bool
Whether to allow scrolling in the iframe. If this ``False``
(default), Streamlit crops any content larger than the iframe and
does not show a scrollbar. If this is ``True``, Streamlit shows a
scrollbar when the content is larger than the iframe.
tab_index : int or None
Specifies how and if the iframe is sequentially focusable.
Users typically use the ``Tab`` key for sequential focus
navigation.
This can be one of the following values:
- ``None`` (default): Uses the browser's default behavior.
- ``-1``: Removes the iframe from sequential navigation, but still
allows it to be focused programmatically.
- ``0``: Includes the iframe in sequential navigation in the order
it appears in the document but after all elements with a positive
``tab_index``.
- Positive integer: Includes the iframe in sequential navigation.
Elements are navigated in ascending order of their positive
``tab_index``.
For more information, see the `tabindex
<https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex>`_
documentation on MDN.
Examples
--------
>>> import streamlit.components.v1 as components
>>>
>>> components.html(
>>> "<p><span style='text-decoration: line-through double red;'>Oops</span>!</p>"
>>> )
iframe = components.v1.iframe(self, src: 'str', width: 'int | None' = None, height: 'int | None' = None, scrolling: 'bool' = False, *, tab_index: 'int | None' = None) -> 'DeltaGenerator'
Load a remote URL in an iframe.
To use this function, import it from the ``streamlit.components.v1``
module.
.. deprecated::
``st.components.v1.iframe`` is deprecated and will be removed in a
future release. Please use ``st.iframe`` instead, which provides
the same functionality with additional features like automatic
content sizing and local file support.
.. warning::
Using ``st.components.v1.iframe`` directly (instead of importing
its module) is deprecated and will be disallowed in a later version.
Parameters
----------
src : str
The URL of the page to embed.
width : int
The width of the iframe in CSS pixels. By default, this is the
app's default element width.
height : int
The height of the frame in CSS pixels. By default, this is ``150``.
scrolling : bool
Whether to allow scrolling in the iframe. If this ``False``
(default), Streamlit crops any content larger than the iframe and
does not show a scrollbar. If this is ``True``, Streamlit shows a
scrollbar when the content is larger than the iframe.
tab_index : int or None
Specifies how and if the iframe is sequentially focusable.
Users typically use the ``Tab`` key for sequential focus
navigation.
This can be one of the following values:
- ``None`` (default): Uses the browser's default behavior.
- ``-1``: Removes the iframe from sequential navigation, but still
allows it to be focused programmatically.
- ``0``: Includes the iframe in sequential navigation in the order
it appears in the document but after all elements with a positive
``tab_index``.
- Positive integer: Includes the iframe in sequential navigation.
Elements are navigated in ascending order of their positive
``tab_index``.
For more information, see the `tabindex
<https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex>`_
documentation on MDN.
Examples
--------
>>> import streamlit.components.v1 as components
>>>
>>> components.iframe("https://example.com", height=500)
DATA
__all__ = ['declare_component', 'html', 'iframe']
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\streamlit\components\v1\__init__.py
streamlit-float.float_box
Python Library Documentation: function float_box in module streamlit_float
float_box(markdown, width='300px', height='300px', top=None, left=None, right=None, bottom=None, background=None, border=None, shadow=None, transition=None, z_index=None, sticky=False, css=None)
# create a floating box containing markdown content
streamlit-float.float_css_helper
Python Library Documentation: function float_css_helper in module streamlit_float
float_css_helper(width=None, height=None, top=None, left=None, right=None, bottom=None, background=None, border=None, shadow=None, transition=None, z_index=None, sticky=False, css='', **kwargs)
# helper function to create css string
streamlit-float.float_dialog
Python Library Documentation: function float_dialog in module streamlit_float
float_dialog(show=False, width=2, background='slategray', transition=2, transition_from='top', transition_to='center', css='')
# Create a floating dialog container
# This needs to be fleshed out more. Add more options for positions, transitions, etc.
streamlit-float.float_init
Python Library Documentation: function float_init in module streamlit_float float_init(theme=True, include_unstable_primary=False)
streamlit-float.float_overlay
Python Library Documentation: function float_overlay in module streamlit_float float_overlay(show=False, z_index='999999', color='#000000', alpha=0.0, blur='1rem', filter=None)
streamlit-float.float_parent
Python Library Documentation: function float_parent in module streamlit_float
float_parent(css=None)
# adds empty div to parent in order to target it with css
# TODO: remove extra gap generated when floating containers. To do this, find the appropriate parent div and set `position: absolute` on it.
streamlit-float.sf_float
Python Library Documentation: function sf_float in module streamlit_float
sf_float(self, css=None)
# float container via its delta generator
# TODO: remove extra gap generated when floating containers. To do this, find the appropriate parent div and set `position: absolute` on it.
streamlit-float.shadow_list
Python Library Documentation: list object class list(object) | list(iterable=(), /) | | Built-in mutable sequence. | | If no argument is given, the constructor creates a new empty list. | The argument must be an iterable if specified. | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return bool(key in self). | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, index, /) | Return self[index]. | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Implement self+=value. | | __imul__(self, value, /) | Implement self*=value. | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __reversed__(self, /) | Return a reverse iterator over the list. | | __rmul__(self, value, /) | Return value*self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __sizeof__(self, /) | Return the size of the list in memory, in bytes. | | append(self, object, /) | Append object to the end of the list. | | clear(self, /) | Remove all items from list. | | copy(self, /) | Return a shallow copy of the list. | | count(self, value, /) | Return number of occurrences of value. | | extend(self, iterable, /) | Extend list by appending elements from the iterable. | | index(self, value, start=0, stop=9223372036854775807, /) | Return first index of value. | | Raises ValueError if the value is not present. | | insert(self, index, object, /) | Insert object before index. | | pop(self, index=-1, /) | Remove and return item at index (default last). | | Raises IndexError if list is empty or index is out of range. | | remove(self, value, /) | Remove first occurrence of value. | | Raises ValueError if the value is not present. | | reverse(self, /) | Reverse *IN PLACE*. | | sort(self, /, *, key=None, reverse=False) | Sort the list in ascending order and return None. | | The sort is in-place (i.e. the list itself is modified) and stable (i.e. the | order of two equal elements is maintained). | | If a key function is given, apply it once to each list item and sort them, | ascending or descending, according to their function values. | | The reverse flag can be set to sort in descending order. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None
streamlit-float.st
Python Library Documentation: package streamlit
NAME
streamlit - Streamlit.
DESCRIPTION
How to use Streamlit in 3 seconds:
1. Write an app
>>> import streamlit as st
>>> st.write(anything_you_want)
2. Run your app
$ streamlit run my_script.py
3. Use your app
A new tab will open on your browser. That's your Streamlit app!
4. Modify your code, save it, and watch changes live on your browser.
Take a look at the other commands in this module to find out what else
Streamlit can do:
>>> dir(streamlit)
Or try running our "Hello World":
$ streamlit hello
For more detailed info, see https://docs.streamlit.io.
PACKAGE CONTENTS
__main__
auth_util
cli_util
column_config
commands (package)
components (package)
config
config_option
config_util
connections (package)
cursor
dataframe_util
delta_generator
delta_generator_singletons
deprecation_util
development
elements (package)
emojis
env_util
error_util
errors
external (package)
file_util
git_util
hello (package)
logger
material_icon_names
navigation (package)
net_util
path_security
platform
proto (package)
runtime (package)
source_util
starlette
string_util
temporary_directory
testing (package)
time_util
type_util
url_util
user_info
util
vendor (package)
version
watcher (package)
web (package)
SUBMODULES
_column_config
_config
_logger
DATA
__annotations__ = {'_bottom': <class 'streamlit.delta_generator.DeltaG...
bottom = <streamlit.elements.bottom.BottomContainerProxy object>
cache_data = <streamlit.runtime.caching.cache_data_api.CacheDataAPI ob...
cache_resource = <streamlit.runtime.caching.cache_resource_api.CacheRe...
context = <streamlit.runtime.context.ContextProxy object>
query_params = <streamlit.runtime.state.query_params_proxy.QueryParams...
secrets = Secrets
session_state = <streamlit.runtime.state.session_state_proxy.SessionSt...
sidebar = DeltaGenerator(_root_container=1, _parent=DeltaGenerator())
user = <streamlit.user_info.UserInfoProxy object>
VERSION
1.57.0
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\streamlit\__init__.py
streamlit-float.theme_init
Python Library Documentation: function theme_init in module streamlit_float theme_init(include_unstable_primary=False)
streamlit-float.transition_list
Python Library Documentation: list object class list(object) | list(iterable=(), /) | | Built-in mutable sequence. | | If no argument is given, the constructor creates a new empty list. | The argument must be an iterable if specified. | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return bool(key in self). | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, index, /) | Return self[index]. | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Implement self+=value. | | __imul__(self, value, /) | Implement self*=value. | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __reversed__(self, /) | Return a reverse iterator over the list. | | __rmul__(self, value, /) | Return value*self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __sizeof__(self, /) | Return the size of the list in memory, in bytes. | | append(self, object, /) | Append object to the end of the list. | | clear(self, /) | Remove all items from list. | | copy(self, /) | Return a shallow copy of the list. | | count(self, value, /) | Return number of occurrences of value. | | extend(self, iterable, /) | Extend list by appending elements from the iterable. | | index(self, value, start=0, stop=9223372036854775807, /) | Return first index of value. | | Raises ValueError if the value is not present. | | insert(self, index, object, /) | Insert object before index. | | pop(self, index=-1, /) | Remove and return item at index (default last). | | Raises IndexError if list is empty or index is out of range. | | remove(self, value, /) | Remove first occurrence of value. | | Raises ValueError if the value is not present. | | reverse(self, /) | Reverse *IN PLACE*. | | sort(self, /, *, key=None, reverse=False) | Sort the list in ascending order and return None. | | The sort is in-place (i.e. the list itself is modified) and stable (i.e. the | order of two equal elements is maintained). | | If a key function is given, apply it once to each list item and sort them, | ascending or descending, according to their function values. | | The reverse flag can be set to sort in descending order. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None
streamlit-float.uuid
Python Library Documentation: module uuid
NAME
uuid - UUID objects (universally unique identifiers) according to RFC 4122.
MODULE REFERENCE
https://docs.python.org/3.12/library/uuid.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module provides immutable UUID objects (class UUID) and the functions
uuid1(), uuid3(), uuid4(), uuid5() for generating version 1, 3, 4, and 5
UUIDs as specified in RFC 4122.
If all you want is a unique ID, you should probably call uuid1() or uuid4().
Note that uuid1() may compromise privacy since it creates a UUID containing
the computer's network address. uuid4() creates a random UUID.
Typical usage:
>>> import uuid
# make a UUID based on the host ID and current time
>>> uuid.uuid1() # doctest: +SKIP
UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')
# make a UUID using an MD5 hash of a namespace UUID and a name
>>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')
# make a random UUID
>>> uuid.uuid4() # doctest: +SKIP
UUID('16fd2706-8baf-433b-82eb-8c7fada847da')
# make a UUID using a SHA-1 hash of a namespace UUID and a name
>>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')
# make a UUID from a string of hex digits (braces and hyphens ignored)
>>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
# convert a UUID to a string of hex digits in standard form
>>> str(x)
'00010203-0405-0607-0809-0a0b0c0d0e0f'
# get the raw 16 bytes of the UUID
>>> x.bytes
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
# make a UUID from a 16-byte string
>>> uuid.UUID(bytes=x.bytes)
UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')
CLASSES
builtins.object
UUID
enum.Enum(builtins.object)
SafeUUID
class SafeUUID(enum.Enum)
| SafeUUID(*values)
|
| An enumeration.
|
| Method resolution order:
| SafeUUID
| enum.Enum
| builtins.object
|
| Data and other attributes defined here:
|
| safe = <SafeUUID.safe: 0>
|
| unknown = <SafeUUID.unknown: None>
|
| unsafe = <SafeUUID.unsafe: -1>
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __contains__(value)
| Return True if `value` is in `cls`.
|
| `value` is in `cls` if:
| 1) `value` is a member of `cls`, or
| 2) `value` is the value of one of the `cls`'s members.
|
| __getitem__(name)
| Return the member matching `name`.
|
| __iter__()
| Return members in definition order.
|
| __len__()
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
class UUID(builtins.object)
| UUID(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
|
| Instances of the UUID class represent UUIDs as specified in RFC 4122.
| UUID objects are immutable, hashable, and usable as dictionary keys.
| Converting a UUID to a string with str() yields something in the form
| '12345678-1234-1234-1234-123456789abc'. The UUID constructor accepts
| five possible forms: a similar string of hexadecimal digits, or a tuple
| of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
| 48-bit values respectively) as an argument named 'fields', or a string
| of 16 bytes (with all the integer fields in big-endian order) as an
| argument named 'bytes', or a string of 16 bytes (with the first three
| fields in little-endian order) as an argument named 'bytes_le', or a
| single 128-bit integer as an argument named 'int'.
|
| UUIDs have these read-only attributes:
|
| bytes the UUID as a 16-byte string (containing the six
| integer fields in big-endian byte order)
|
| bytes_le the UUID as a 16-byte string (with time_low, time_mid,
| and time_hi_version in little-endian byte order)
|
| fields a tuple of the six integer fields of the UUID,
| which are also available as six individual attributes
| and two derived attributes:
|
| time_low the first 32 bits of the UUID
| time_mid the next 16 bits of the UUID
| time_hi_version the next 16 bits of the UUID
| clock_seq_hi_variant the next 8 bits of the UUID
| clock_seq_low the next 8 bits of the UUID
| node the last 48 bits of the UUID
|
| time the 60-bit timestamp
| clock_seq the 14-bit sequence number
|
| hex the UUID as a 32-character hexadecimal string
|
| int the UUID as a 128-bit integer
|
| urn the UUID as a URN as specified in RFC 4122
|
| variant the UUID variant (one of the constants RESERVED_NCS,
| RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
|
| version the UUID version number (1 through 5, meaningful only
| when the variant is RFC_4122)
|
| is_safe An enum indicating whether the UUID has been generated in
| a way that is safe for multiprocessing applications, via
| uuid_generate_time_safe(3).
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getstate__(self)
| Helper for pickle.
|
| __gt__(self, other)
| Return self>value.
|
| __hash__(self)
| Return hash(self).
|
| __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
| Create a UUID from either a string of 32 hexadecimal digits,
| a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
| in little-endian order as the 'bytes_le' argument, a tuple of six
| integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
| 8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
| the 'fields' argument, or a single 128-bit integer as the 'int'
| argument. When a string of hex digits is given, curly braces,
| hyphens, and a URN prefix are all optional. For example, these
| expressions all yield the same UUID:
|
| UUID('{12345678-1234-5678-1234-567812345678}')
| UUID('12345678123456781234567812345678')
| UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
| UUID(bytes='\x12\x34\x56\x78'*4)
| UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
| '\x12\x34\x56\x78\x12\x34\x56\x78')
| UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
| UUID(int=0x12345678123456781234567812345678)
|
| Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
| be given. The 'version' argument is optional; if given, the resulting
| UUID will have its variant and version set according to RFC 4122,
| overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
|
| is_safe is an enum exposed as an attribute on the instance. It
| indicates whether the UUID has been generated in a way that is safe
| for multiprocessing applications, via uuid_generate_time_safe(3).
|
| __int__(self)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, name, value)
| Implement setattr(self, name, value).
|
| __setstate__(self, state)
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| bytes
|
| bytes_le
|
| clock_seq
|
| clock_seq_hi_variant
|
| clock_seq_low
|
| fields
|
| hex
|
| node
|
| time
|
| time_hi_version
|
| time_low
|
| time_mid
|
| urn
|
| variant
|
| version
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| int
|
| is_safe
FUNCTIONS
getnode()
Get the hardware address as a 48-bit positive integer.
The first time this runs, it may launch a separate program, which could
be quite slow. If all attempts to obtain the hardware address fail, we
choose a random 48-bit number with its eighth bit set to 1 as recommended
in RFC 4122.
main()
Run the uuid command line interface.
uuid1(node=None, clock_seq=None)
Generate a UUID from a host ID, sequence number, and the current time.
If 'node' is not given, getnode() is used to obtain the hardware
address. If 'clock_seq' is given, it is used as the sequence number;
otherwise a random 14-bit sequence number is chosen.
uuid3(namespace, name)
Generate a UUID from the MD5 hash of a namespace UUID and a name.
uuid4()
Generate a random UUID.
uuid5(namespace, name)
Generate a UUID from the SHA-1 hash of a namespace UUID and a name.
DATA
NAMESPACE_DNS = UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8')
NAMESPACE_URL = UUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8')
NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8')
RESERVED_FUTURE = 'reserved for future definition'
RESERVED_MICROSOFT = 'reserved for Microsoft compatibility'
RESERVED_NCS = 'reserved for NCS compatibility'
RFC_4122 = 'specified in RFC 4122'
AUTHOR
Ka-Ping Yee <ping@zesty.ca>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\uuid.py