Dictionary

1{"level": [1, 2, 3],
2 "conf": [-1, 1, 2],
3 "text": ["here", "hel", "llo"]}
4

1{"level": [1, 2, 3],
2 "conf": [-1, 1, 2],
3 "text": ["here", "hel", "llo"]}
4{"level": [2, 3],
5 "conf": [1, 2],
6 "text": ["hel", "llo"]}
7

1{"level": [1, 2, 3],
2 "conf": [-1, 1, 2],
3 "text": ["here", "hel", "llo"]}
4{"level": [2, 3],
5 "conf": [1, 2],
6 "text": ["hel", "llo"]}
7new_dict = {i: [a for a in j if a >= min_conf] for i, j in my_dict.items()}
8

1class Userattribute(BaseModel):
2    name: str
3    value: str
4    user_id: str
5    id: str
6

1class Userattribute(BaseModel):
2    name: str
3    value: str
4    user_id: str
5    id: str
6class Userattribute(Base):
7    __tablename__ = "user_attribute"
8
9    name = Column(String)
10    value = Column(String)
11    user_id = Column(String)
12    id = Column(String, primary_key=True, index=True)
13

1class Userattribute(BaseModel):
2    name: str
3    value: str
4    user_id: str
5    id: str
6class Userattribute(Base):
7    __tablename__ = "user_attribute"
8
9    name = Column(String)
10    value = Column(String)
11    user_id = Column(String)
12    id = Column(String, primary_key=True, index=True)
13def get_attributes(db: Session, skip: int = 0, limit: int = 100):
14    return db.query(models.Userattribute).offset(skip).limit(limit).all()
15

1class Userattribute(BaseModel):
2    name: str
3    value: str
4    user_id: str
5    id: str
6class Userattribute(Base):
7    __tablename__ = "user_attribute"
8
9    name = Column(String)
10    value = Column(String)
11    user_id = Column(String)
12    id = Column(String, primary_key=True, index=True)
13def get_attributes(db: Session, skip: int = 0, limit: int = 100):
14    return db.query(models.Userattribute).offset(skip).limit(limit).all()
15@app.get("/attributes/", response_model=List[schemas.Userattribute])
16def read_attributes(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
17    users = crud.get_attributes(db, skip=skip, limit=limit)
18    print(users)
19    return users
20

1class Userattribute(BaseModel):
2    name: str
3    value: str
4    user_id: str
5    id: str
6class Userattribute(Base):
7    __tablename__ = "user_attribute"
8
9    name = Column(String)
10    value = Column(String)
11    user_id = Column(String)
12    id = Column(String, primary_key=True, index=True)
13def get_attributes(db: Session, skip: int = 0, limit: int = 100):
14    return db.query(models.Userattribute).offset(skip).limit(limit).all()
15@app.get("/attributes/", response_model=List[schemas.Userattribute])
16def read_attributes(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
17    users = crud.get_attributes(db, skip=skip, limit=limit)
18    print(users)
19    return users
20pydantic.error_wrappers.ValidationError: 7 validation errors for Userattribute
21response -> 0
22  value is not a valid dict (type=type_error.dict)
23response -> 1
24  value is not a valid dict (type=type_error.dict)
25response -> 2
26  value is not a valid dict (type=type_error.dict)
27response -> 3
28  value is not a valid dict (type=type_error.dict)
29response -> 4
30  value is not a valid dict (type=type_error.dict)
31response -> 5
32  value is not a valid dict (type=type_error.dict)
33response -> 6
34  value is not a valid dict (type=type_error.dict)
35

1public class HelloHun {
2    public static void main(String[] args) {
3        MemoryAddress hunspellHandle = null;
4        try (ResourceScope scope = ResourceScope.newConfinedScope()) {
5            var allocator = SegmentAllocator.nativeAllocator(scope);
6
7            // Point it to US english dictionary and (so called) affix file
8            // Note #1: it is possible to add words to the dictionary if you like
9            // Note #2: it is possible to have separate/individual dictionaries and affix files (e.g. per user/doc type)
10            var en_US_aff = allocator.allocateUtf8String("/usr/share/hunspell/en_US.aff");
11            var en_US_dic = allocator.allocateUtf8String("/usr/share/hunspell/en_US.dic");
12
13            // Get a handle to the Hunspell shared library and load up the dictionary and affix
14            hunspellHandle = Hunspell_create(en_US_aff, en_US_dic);
15
16            // Feed it a wrong word
17            var javaWord = "koing";
18
19            // Do a simple spell check of the word
20            var word = allocator.allocateUtf8String(javaWord);
21            var spellingResult = Hunspell_spell(hunspellHandle, word);
22            System.out.println(String.format("%s is spelled %s", javaWord, (spellingResult == 0 ? "incorrect" : "correct")));
23
24            // Hunspell also supports giving suggestions for a word - which is what we do next
25            // Note #3: by testing this `koing` word in isolation - we know that there are 4 alternatives for this word
26            // Note #4: I'm still investigating how to access individual suggestions
27
28            var suggestions = allocator.allocate(10);
29            var suggestionCount = Hunspell_suggest(hunspellHandle, suggestions, word);
30
31            System.out.println(String.format("There are %d suggestions for %s", suggestionCount, javaWord));
32
33            // `suggestions` - according to the hunspell API - is a `pointer to an array of strings pointer`
34            // we know how many `strings` pointer there are, as that is the returned value from `suggest`
35            // Question: how to process `suggestions` to get individual suggestions
36
37
38        } finally {
39            if (hunspellHandle != null) {
40                Hunspell_destroy(hunspellHandle);
41            }
42        }
43    }
44}
45

1jsons = ["{'added': [(59, 'dep1_v2'), (60, 'dep2_v2')], 'deleted': [(59, 'dep1_v1'), (60, 'dep2_v1')]}",
2         "{'added': [(61, 'dep3_v2')], 'deleted': [(61, 'dep3_v1')]}"]
3
4df = pd.DataFrame({"col1": ["value1", "value2"], "col2": jsons})
5

1jsons = ["{'added': [(59, 'dep1_v2'), (60, 'dep2_v2')], 'deleted': [(59, 'dep1_v1'), (60, 'dep2_v1')]}",
2         "{'added': [(61, 'dep3_v2')], 'deleted': [(61, 'dep3_v1')]}"]
3
4df = pd.DataFrame({"col1": ["value1", "value2"], "col2": jsons})
5df = df.join(pd.json_normalize(df.col2))
6df.drop(columns=['col2'], inplace=True)
7

1dictionary = Dict(1 => 77, 2 => 66, 3 => 1)
2

1dictionary = Dict(1 => 77, 2 => 66, 3 => 1)
2> keys(dictionary)
3
4# [output] 
5KeySet for a Dict{Int64, Int64} with 3 entries. Keys:
62
73
81
9
10# now i want to make sure Julia consider above order. so i use collect and then i will call first element of it
11> collect(keys(dictionary))[1]
12
13# [output] 
142
15

1dictionary = Dict(1 => 77, 2 => 66, 3 => 1)
2> keys(dictionary)
3
4# [output] 
5KeySet for a Dict{Int64, Int64} with 3 entries. Keys:
62
73
81
9
10# now i want to make sure Julia consider above order. so i use collect and then i will call first element of it
11> collect(keys(dictionary))[1]
12
13# [output] 
142
15> keys(dictionary)
16
17# [output] 
18KeySet for a Dict{Int64, Int64} with 3 entries. Keys:
191
202
213
22
23> collect(keys(dictionary))[1]
24
25# [output] 
261
27

1row1 = list(range(1, 6, 1))
2row2 = list(range(6, 11, 1))
3row3 = list(range(11, 16, 1))
4row4 = list(range(16, 21, 1))
5
6row1_dict = {}
7row2_dict = {}
8row3_dict = {}
9row4_dict = {}
10
11for n in row1:
12    row1_dict[n] = 1
13for n in row2:
14    row2_dict[n] = 2
15for n in row3:
16    row3_dict[n] = 3
17for n in row4:
18    row4_dict[n] = 4
19
20id_to_row_dict = {}
21id_to_row_dict = {**row1_dict, **row2_dict, **row3_dict, **row4_dict}
22print('\n')
23for k, v in id_to_row_dict.items():
24    print(k, " : ", v)
25

1row1 = list(range(1, 6, 1))
2row2 = list(range(6, 11, 1))
3row3 = list(range(11, 16, 1))
4row4 = list(range(16, 21, 1))
5
6row1_dict = {}
7row2_dict = {}
8row3_dict = {}
9row4_dict = {}
10
11for n in row1:
12    row1_dict[n] = 1
13for n in row2:
14    row2_dict[n] = 2
15for n in row3:
16    row3_dict[n] = 3
17for n in row4:
18    row4_dict[n] = 4
19
20id_to_row_dict = {}
21id_to_row_dict = {**row1_dict, **row2_dict, **row3_dict, **row4_dict}
22print('\n')
23for k, v in id_to_row_dict.items():
24    print(k, " : ", v)
251  :  1
262  :  1
273  :  1
284  :  1
295  :  1
306  :  2
317  :  2
328  :  2
339  :  2
3410  :  2
3511  :  3
3612  :  3
3713  :  3
3814  :  3
3915  :  3
4016  :  4
4117  :  4
4218  :  4
4319  :  4
4420  :  4
45

1from timeit import timeit
2
3dct1 = {str(i): 1 for i in range(10**7)}
4dct2 = {i: 1 for i in range(10**7)}
5
6print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
7print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
8

1from timeit import timeit
2
3dct1 = {str(i): 1 for i in range(10**7)}
4dct2 = {i: 1 for i in range(10**7)}
5
6print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
7print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
82.529034548999334
92.212983401999736
10

1from timeit import timeit
2
3dct1 = {str(i): 1 for i in range(10**7)}
4dct2 = {i: 1 for i in range(10**7)}
5
6print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
7print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
82.529034548999334
92.212983401999736
10dct1[7] = 1
11dct2["7"] = 1
12
13print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
14print(timeit('7 in dct1', setup='from __main__ import dct1', number=10**8))
15print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
16print(timeit('"7" in dct2', setup='from __main__ import dct2', number=10**8))
17

1from timeit import timeit
2
3dct1 = {str(i): 1 for i in range(10**7)}
4dct2 = {i: 1 for i in range(10**7)}
5
6print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
7print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
82.529034548999334
92.212983401999736
10dct1[7] = 1
11dct2["7"] = 1
12
13print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
14print(timeit('7 in dct1', setup='from __main__ import dct1', number=10**8))
15print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
16print(timeit('"7" in dct2', setup='from __main__ import dct2', number=10**8))
173.443614432000686
182.6335261530002754
192.1873921409987815
202.272667104998618
21

1from timeit import timeit
2
3dct1 = {str(i): 1 for i in range(10**7)}
4dct2 = {i: 1 for i in range(10**7)}
5
6print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
7print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
82.529034548999334
92.212983401999736
10dct1[7] = 1
11dct2["7"] = 1
12
13print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
14print(timeit('7 in dct1', setup='from __main__ import dct1', number=10**8))
15print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
16print(timeit('"7" in dct2', setup='from __main__ import dct2', number=10**8))
173.443614432000686
182.6335261530002754
192.1873921409987815
202.272667104998618
21from timeit import timeit
22
23dct1 = {str(i): 1 for i in range(10**7)}
24dct2 = {i: 1 for i in range(10**7)}
25
26print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
27# 2.55
28print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
29# 2.26
30
317 in dct1
32"7" in dct2
33
34print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
35# 3.34
36print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
37# 2.35
38

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10>>> UsesMeta.greet_user()
11Hello, I'm the class 'UsesMeta'!
12

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10>>> UsesMeta.greet_user()
11Hello, I'm the class 'UsesMeta'!
12Help on class UsesMeta in module __main__:
13class UsesMeta(builtins.object)
14 |  A class that uses `Meta` as its metaclass.
15 |  
16 |  Data descriptors defined here:
17 |  
18 |  __dict__
19 |      dictionary for instance variables (if defined)
20 |  
21 |  __weakref__
22 |      list of weak references to the object (if defined)
23

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10>>> UsesMeta.greet_user()
11Hello, I'm the class 'UsesMeta'!
12Help on class UsesMeta in module __main__:
13class UsesMeta(builtins.object)
14 |  A class that uses `Meta` as its metaclass.
15 |  
16 |  Data descriptors defined here:
17 |  
18 |  __dict__
19 |      dictionary for instance variables (if defined)
20 |  
21 |  __weakref__
22 |      list of weak references to the object (if defined)
23from pydoc import render_doc
24from functools import cache
25
26def get_documentation(func_or_cls):
27    """Get the output printed by the `help` function as a string"""
28    return '\n'.join(render_doc(func_or_cls).splitlines()[2:])
29
30
31class Meta(type):
32    """A python metaclass."""
33
34    @classmethod
35    @cache
36    def _docs(metacls) -> str:
37        """Get the documentation for all public methods and properties defined in the metaclass."""
38
39        divider = '\n\n----------------------------------------------\n\n'
40        metacls_name = metacls.__name__
41        metacls_dict = metacls.__dict__
42
43        methods_header = (
44            f'Classmethods inherited from metaclass `{metacls_name}`'
45            f'\n\n'
46        )
47
48        method_docstrings = '\n\n'.join(
49            get_documentation(method)
50            for method_name, method in metacls_dict.items()
51            if not (method_name.startswith('_') or isinstance(method, property))
52        )
53
54        properties_header = (
55            f'Classmethod properties inherited from metaclass `{metacls_name}`'
56            f'\n\n'
57        )
58
59        properties_docstrings = '\n\n'.join(
60            f'{property_name}\n{get_documentation(prop)}'
61            for property_name, prop in metacls_dict.items()
62            if isinstance(prop, property) and not property_name.startswith('_')
63        )
64
65        return ''.join((
66            divider,
67            methods_header,
68            method_docstrings,
69            divider,
70            properties_header,
71            properties_docstrings,
72            divider
73        ))
74
75
76    def __new__(metacls, cls_name, cls_bases, cls_dict):
77        """Make a new class, but tweak `.__doc__` so it includes information about the metaclass's methods."""
78
79        new = super().__new__(metacls, cls_name, cls_bases, cls_dict)
80        metacls_docs = metacls._docs()
81
82        if new.__doc__ is None:
83            new.__doc__ = metacls_docs
84        else:
85            new.__doc__ += metacls_docs
86
87        return new
88
89    def greet_user(cls):
90        """Print a friendly greeting identifying the class's name."""
91        print(f"Hello, I'm the class '{cls.__name__}'!")
92
93    
94class UsesMeta(metaclass=Meta):
95    """A class that uses `Meta` as its metaclass."""
96

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10>>> UsesMeta.greet_user()
11Hello, I'm the class 'UsesMeta'!
12Help on class UsesMeta in module __main__:
13class UsesMeta(builtins.object)
14 |  A class that uses `Meta` as its metaclass.
15 |  
16 |  Data descriptors defined here:
17 |  
18 |  __dict__
19 |      dictionary for instance variables (if defined)
20 |  
21 |  __weakref__
22 |      list of weak references to the object (if defined)
23from pydoc import render_doc
24from functools import cache
25
26def get_documentation(func_or_cls):
27    """Get the output printed by the `help` function as a string"""
28    return '\n'.join(render_doc(func_or_cls).splitlines()[2:])
29
30
31class Meta(type):
32    """A python metaclass."""
33
34    @classmethod
35    @cache
36    def _docs(metacls) -> str:
37        """Get the documentation for all public methods and properties defined in the metaclass."""
38
39        divider = '\n\n----------------------------------------------\n\n'
40        metacls_name = metacls.__name__
41        metacls_dict = metacls.__dict__
42
43        methods_header = (
44            f'Classmethods inherited from metaclass `{metacls_name}`'
45            f'\n\n'
46        )
47
48        method_docstrings = '\n\n'.join(
49            get_documentation(method)
50            for method_name, method in metacls_dict.items()
51            if not (method_name.startswith('_') or isinstance(method, property))
52        )
53
54        properties_header = (
55            f'Classmethod properties inherited from metaclass `{metacls_name}`'
56            f'\n\n'
57        )
58
59        properties_docstrings = '\n\n'.join(
60            f'{property_name}\n{get_documentation(prop)}'
61            for property_name, prop in metacls_dict.items()
62            if isinstance(prop, property) and not property_name.startswith('_')
63        )
64
65        return ''.join((
66            divider,
67            methods_header,
68            method_docstrings,
69            divider,
70            properties_header,
71            properties_docstrings,
72            divider
73        ))
74
75
76    def __new__(metacls, cls_name, cls_bases, cls_dict):
77        """Make a new class, but tweak `.__doc__` so it includes information about the metaclass's methods."""
78
79        new = super().__new__(metacls, cls_name, cls_bases, cls_dict)
80        metacls_docs = metacls._docs()
81
82        if new.__doc__ is None:
83            new.__doc__ = metacls_docs
84        else:
85            new.__doc__ += metacls_docs
86
87        return new
88
89    def greet_user(cls):
90        """Print a friendly greeting identifying the class's name."""
91        print(f"Hello, I'm the class '{cls.__name__}'!")
92
93    
94class UsesMeta(metaclass=Meta):
95    """A class that uses `Meta` as its metaclass."""
96Help on class UsesMeta in module __main__:
97class UsesMeta(builtins.object)
98 |  A class that uses `Meta` as its metaclass.
99 |  
100 |  ----------------------------------------------
101 |  
102 |  Classmethods inherited from metaclass `Meta`
103 |  
104 |  greet_user(cls)
105 |      Print a friendly greeting identifying the class's name.
106 |  
107 |  ----------------------------------------------
108 |  
109 |  Classmethod properties inherited from metaclass `Meta`
110 |  
111 |  
112 |  
113 |  ----------------------------------------------
114 |  
115 |  Data descriptors defined here:
116 |  
117 |  __dict__
118 |      dictionary for instance variables (if defined)
119 |  
120 |  __weakref__
121 |      list of weak references to the object (if defined)
122

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10>>> UsesMeta.greet_user()
11Hello, I'm the class 'UsesMeta'!
12Help on class UsesMeta in module __main__:
13class UsesMeta(builtins.object)
14 |  A class that uses `Meta` as its metaclass.
15 |  
16 |  Data descriptors defined here:
17 |  
18 |  __dict__
19 |      dictionary for instance variables (if defined)
20 |  
21 |  __weakref__
22 |      list of weak references to the object (if defined)
23from pydoc import render_doc
24from functools import cache
25
26def get_documentation(func_or_cls):
27    """Get the output printed by the `help` function as a string"""
28    return '\n'.join(render_doc(func_or_cls).splitlines()[2:])
29
30
31class Meta(type):
32    """A python metaclass."""
33
34    @classmethod
35    @cache
36    def _docs(metacls) -> str:
37        """Get the documentation for all public methods and properties defined in the metaclass."""
38
39        divider = '\n\n----------------------------------------------\n\n'
40        metacls_name = metacls.__name__
41        metacls_dict = metacls.__dict__
42
43        methods_header = (
44            f'Classmethods inherited from metaclass `{metacls_name}`'
45            f'\n\n'
46        )
47
48        method_docstrings = '\n\n'.join(
49            get_documentation(method)
50            for method_name, method in metacls_dict.items()
51            if not (method_name.startswith('_') or isinstance(method, property))
52        )
53
54        properties_header = (
55            f'Classmethod properties inherited from metaclass `{metacls_name}`'
56            f'\n\n'
57        )
58
59        properties_docstrings = '\n\n'.join(
60            f'{property_name}\n{get_documentation(prop)}'
61            for property_name, prop in metacls_dict.items()
62            if isinstance(prop, property) and not property_name.startswith('_')
63        )
64
65        return ''.join((
66            divider,
67            methods_header,
68            method_docstrings,
69            divider,
70            properties_header,
71            properties_docstrings,
72            divider
73        ))
74
75
76    def __new__(metacls, cls_name, cls_bases, cls_dict):
77        """Make a new class, but tweak `.__doc__` so it includes information about the metaclass's methods."""
78
79        new = super().__new__(metacls, cls_name, cls_bases, cls_dict)
80        metacls_docs = metacls._docs()
81
82        if new.__doc__ is None:
83            new.__doc__ = metacls_docs
84        else:
85            new.__doc__ += metacls_docs
86
87        return new
88
89    def greet_user(cls):
90        """Print a friendly greeting identifying the class's name."""
91        print(f"Hello, I'm the class '{cls.__name__}'!")
92
93    
94class UsesMeta(metaclass=Meta):
95    """A class that uses `Meta` as its metaclass."""
96Help on class UsesMeta in module __main__:
97class UsesMeta(builtins.object)
98 |  A class that uses `Meta` as its metaclass.
99 |  
100 |  ----------------------------------------------
101 |  
102 |  Classmethods inherited from metaclass `Meta`
103 |  
104 |  greet_user(cls)
105 |      Print a friendly greeting identifying the class's name.
106 |  
107 |  ----------------------------------------------
108 |  
109 |  Classmethod properties inherited from metaclass `Meta`
110 |  
111 |  
112 |  
113 |  ----------------------------------------------
114 |  
115 |  Data descriptors defined here:
116 |  
117 |  __dict__
118 |      dictionary for instance variables (if defined)
119 |  
120 |  __weakref__
121 |      list of weak references to the object (if defined)
122from enum import Enum
123
124class FooEnum(Enum):
125    BAR = 1
126

1class Meta(type):
2    """A python metaclass."""
3    def greet_user(cls):
4        """Print a friendly greeting identifying the class's name."""
5        print(f"Hello, I'm the class '{cls.__name__}'!")
6
7    
8class UsesMeta(metaclass=Meta):
9    """A class that uses `Meta` as its metaclass."""
10>>> UsesMeta.greet_user()
11Hello, I'm the class 'UsesMeta'!
12Help on class UsesMeta in module __main__:
13class UsesMeta(builtins.object)
14 |  A class that uses `Meta` as its metaclass.
15 |  
16 |  Data descriptors defined here:
17 |  
18 |  __dict__
19 |      dictionary for instance variables (if defined)
20 |  
21 |  __weakref__
22 |      list of weak references to the object (if defined)
23from pydoc import render_doc
24from functools import cache
25
26def get_documentation(func_or_cls):
27    """Get the output printed by the `help` function as a string"""
28    return '\n'.join(render_doc(func_or_cls).splitlines()[2:])
29
30
31class Meta(type):
32    """A python metaclass."""
33
34    @classmethod
35    @cache
36    def _docs(metacls) -> str:
37        """Get the documentation for all public methods and properties defined in the metaclass."""
38
39        divider = '\n\n----------------------------------------------\n\n'
40        metacls_name = metacls.__name__
41        metacls_dict = metacls.__dict__
42
43        methods_header = (
44            f'Classmethods inherited from metaclass `{metacls_name}`'
45            f'\n\n'
46        )
47
48        method_docstrings = '\n\n'.join(
49            get_documentation(method)
50            for method_name, method in metacls_dict.items()
51            if not (method_name.startswith('_') or isinstance(method, property))
52        )
53
54        properties_header = (
55            f'Classmethod properties inherited from metaclass `{metacls_name}`'
56            f'\n\n'
57        )
58
59        properties_docstrings = '\n\n'.join(
60            f'{property_name}\n{get_documentation(prop)}'
61            for property_name, prop in metacls_dict.items()
62            if isinstance(prop, property) and not property_name.startswith('_')
63        )
64
65        return ''.join((
66            divider,
67            methods_header,
68            method_docstrings,
69            divider,
70            properties_header,
71            properties_docstrings,
72            divider
73        ))
74
75
76    def __new__(metacls, cls_name, cls_bases, cls_dict):
77        """Make a new class, but tweak `.__doc__` so it includes information about the metaclass's methods."""
78
79        new = super().__new__(metacls, cls_name, cls_bases, cls_dict)
80        metacls_docs = metacls._docs()
81
82        if new.__doc__ is None:
83            new.__doc__ = metacls_docs
84        else:
85            new.__doc__ += metacls_docs
86
87        return new
88
89    def greet_user(cls):
90        """Print a friendly greeting identifying the class's name."""
91        print(f"Hello, I'm the class '{cls.__name__}'!")
92
93    
94class UsesMeta(metaclass=Meta):
95    """A class that uses `Meta` as its metaclass."""
96Help on class UsesMeta in module __main__:
97class UsesMeta(builtins.object)
98 |  A class that uses `Meta` as its metaclass.
99 |  
100 |  ----------------------------------------------
101 |  
102 |  Classmethods inherited from metaclass `Meta`
103 |  
104 |  greet_user(cls)
105 |      Print a friendly greeting identifying the class's name.
106 |  
107 |  ----------------------------------------------
108 |  
109 |  Classmethod properties inherited from metaclass `Meta`
110 |  
111 |  
112 |  
113 |  ----------------------------------------------
114 |  
115 |  Data descriptors defined here:
116 |  
117 |  __dict__
118 |      dictionary for instance variables (if defined)
119 |  
120 |  __weakref__
121 |      list of weak references to the object (if defined)
122from enum import Enum
123
124class FooEnum(Enum):
125    BAR = 1
126 |  ----------------------------------------------------------------------
127 |  Readonly properties inherited from enum.EnumMeta:
128 |  
129 |  __members__
130 |      Returns a mapping of member name->value.
131 |      
132 |      This mapping lists all enum members, including aliases. Note that this
133 |      is a read-only view of the internal mapping.
134