openapi-parser 0.3.0__tar.gz

openapi_parser-0.3.0/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2021-2026, Peter Zaitcev
+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.
+
+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.

openapi_parser-0.3.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: openapi-parser
+Version: 0.3.0
+Summary: OpenAPI 3.0 specs parser and client/server generator
+Home-page: https://gitlab.com/Hares-Lab/libraries/openapi-parser
+Author: Peter Zaitcev / USSX Hares
+Maintainer: Peter Zaitcev / USSX Hares
+License: BSD 2-Clause License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML~=6.0.1
+Requires-Dist: functional-python~=0.4.0
+Requires-Dist: http-server-base~=2.0.10
+Requires-Dist: license~=0.1a3
+Requires-Dist: stringcase~=1.2.0
+Requires-Dist: tornado~=6.2; python_version <= "3.8"
+Requires-Dist: tornado~=6.5; python_version >= "3.9"
+Requires-Dist: backports.cached-property~=1.0.2; python_version < "3.8"
+Requires-Dist: singledispatchmethod~=1.0; python_version < "3.8"
+Provides-Extra: test
+Requires-Dist: wheel; extra == "test"
+Requires-Dist: lxml; extra == "test"
+Requires-Dist: unittest-xml-reporting; extra == "test"
+Provides-Extra: all
+Requires-Dist: wheel; extra == "all"
+Requires-Dist: lxml; extra == "all"
+Requires-Dist: unittest-xml-reporting; extra == "all"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OpenAPI 3.0 Parser
+This package provides functionality to analyze [OpenAPI 3.0 Specification] files
+and build clients and servers from that specification.
+
+For more details, please refer the [Project Documentation]
+
+### Example Usage
+From the command line:
+```bash
+$ python -m openapi_parser data/petstore.yaml 
+```
+
+From the Python:
+```python
+from openapi_parser.exporter import PackageWriter
+from openapi_parser.parser.loader import OpenApiParser
+
+def main():
+    parser = OpenApiParser.open('data/petstore.yaml')
+    parser.load_all()
+    
+    package_writer = PackageWriter(parser)
+    package_writer.write_package()
+    
+    return 0
+
+if (__name__ == '__main__'):
+    exit_code = main()
+    exit(exit_code)
+```
+
+### TODOs:
+ - [x] Model generator:
+    - [x] Core functionality
+    - [x] Class inheritance support
+    - [x] Enums support
+    - [ ] Required properties in combination with `readOnly`/`writeOnly`
+    - [x] Discriminator property support
+    - [ ] Cyclic refs resolution
+    - [ ] Support of `additionalProperties` inside class
+ - [x] Client generator
+    - [x] Core functionality
+    - [x] Smart body encoding
+    - [x] Smart response decoding
+    - [ ] `style`-encoding
+    - [ ] `schema` and `content` inside parameters conflict support
+    - [x] Enums for parameters support
+    - [ ] Cookies parameters support
+    - [x] Methods descriptions
+    - [ ] Authorization support
+ - [x] Metadata extractor
+    - [x] Version
+    - [x] Licence
+    - [x] Description
+    - [x] Servers
+    - [x] Security definitions
+ - [ ] Server generator
+ - [ ] Test coverage
+ - [ ] Documentation
+ - [x] Command-line interface
+    - [x] Basic CLI support
+    - [ ] Extended CLI support
+
+### See Also:
+ - [Project Documentation]
+ - [OpenAPI 3.0 Specification]
+ - [JSON Schema Standard]
+
+[Project Documentation]: https://hares-lab.gitlab.io/openapi-parser
+[OpenAPI 3.0 Specification]: https://swagger.io/specification
+[JSON Schema Standard]: https://tools.ietf.org/html/draft-wright-json-schema-validation-00

openapi_parser-0.3.0/README.md

@@ -0,0 +1,71 @@
+# OpenAPI 3.0 Parser
+This package provides functionality to analyze [OpenAPI 3.0 Specification] files
+and build clients and servers from that specification.
+
+For more details, please refer the [Project Documentation]
+
+### Example Usage
+From the command line:
+```bash
+$ python -m openapi_parser data/petstore.yaml 
+```
+
+From the Python:
+```python
+from openapi_parser.exporter import PackageWriter
+from openapi_parser.parser.loader import OpenApiParser
+
+def main():
+    parser = OpenApiParser.open('data/petstore.yaml')
+    parser.load_all()
+    
+    package_writer = PackageWriter(parser)
+    package_writer.write_package()
+    
+    return 0
+
+if (__name__ == '__main__'):
+    exit_code = main()
+    exit(exit_code)
+```
+
+### TODOs:
+ - [x] Model generator:
+    - [x] Core functionality
+    - [x] Class inheritance support
+    - [x] Enums support
+    - [ ] Required properties in combination with `readOnly`/`writeOnly`
+    - [x] Discriminator property support
+    - [ ] Cyclic refs resolution
+    - [ ] Support of `additionalProperties` inside class
+ - [x] Client generator
+    - [x] Core functionality
+    - [x] Smart body encoding
+    - [x] Smart response decoding
+    - [ ] `style`-encoding
+    - [ ] `schema` and `content` inside parameters conflict support
+    - [x] Enums for parameters support
+    - [ ] Cookies parameters support
+    - [x] Methods descriptions
+    - [ ] Authorization support
+ - [x] Metadata extractor
+    - [x] Version
+    - [x] Licence
+    - [x] Description
+    - [x] Servers
+    - [x] Security definitions
+ - [ ] Server generator
+ - [ ] Test coverage
+ - [ ] Documentation
+ - [x] Command-line interface
+    - [x] Basic CLI support
+    - [ ] Extended CLI support
+
+### See Also:
+ - [Project Documentation]
+ - [OpenAPI 3.0 Specification]
+ - [JSON Schema Standard]
+
+[Project Documentation]: https://hares-lab.gitlab.io/openapi-parser
+[OpenAPI 3.0 Specification]: https://swagger.io/specification
+[JSON Schema Standard]: https://tools.ietf.org/html/draft-wright-json-schema-validation-00

openapi_parser-0.3.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ['setuptools', 'extended-setup-tools >= 0.2.6']
+build-backend = 'setuptools.build_meta'

openapi_parser-0.3.0/requirements.txt

@@ -0,0 +1,11 @@
+PyYAML ~= 6.0.1
+functional-python ~= 0.4.0
+http-server-base ~= 2.0.10
+license ~= 0.1a3
+stringcase ~= 1.2.0
+tornado ~= 6.2 ; python_version <= "3.8"
+tornado ~= 6.5 ; python_version >= "3.9"
+
+# Backports
+backports.cached-property ~= 1.0.2 ; python_version < "3.8"
+singledispatchmethod ~= 1.0 ; python_version < "3.8"

openapi_parser-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

openapi_parser-0.3.0/setup.py

@@ -0,0 +1,29 @@
+from extended_setup import ExtendedSetupManager
+
+
+ExtendedSetupManager('openapi-parser').setup \
+(
+    license = "BSD 2-Clause License",
+    short_description = "OpenAPI 3.0 specs parser and client/server generator",
+    min_python_version = '3.7',
+    classifiers =
+    [
+        'Development Status :: 2 - Pre-Alpha',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
+        'Programming Language :: Python :: 3.14',
+        'Topic :: Software Development :: Code Generators',
+        'Topic :: Software Development :: Libraries',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        'Topic :: Utilities',
+        'Typing :: Typed',
+    ]
+)

openapi_parser-0.3.0/src/openapi_parser/__init__.py

@@ -0,0 +1,26 @@
+"""
+.. include:: ../../README.md
+"""
+
+from collections import namedtuple
+
+__title__ = 'openapi-parser'
+__author__ = 'Peter Zaitcev / USSX Hares'
+__license__ = 'BSD 2-clause'
+__copyright__ = 'Copyright 2020-2026 Peter Zaitcev'
+__version__ = '0.3.0'
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro releaselevel serial')
+version_info = VersionInfo(*__version__.split('.'), releaselevel='alpha', serial=0)
+
+__all__ = \
+[
+    'version_info',
+    '__title__',
+    '__author__',
+    '__license__',
+    '__copyright__',
+    '__version__',
+]
+__pdoc__ = { }
+__pdoc_extras__ = [ ]

openapi_parser-0.3.0/src/openapi_parser/__main__.py

@@ -0,0 +1,5 @@
+from openapi_parser.cli import cli
+
+if (__name__ == '__main__'):
+    exit_code = cli()
+    exit(exit_code)

openapi_parser-0.3.0/src/openapi_parser/cli.py

@@ -0,0 +1,103 @@
+import sys
+from logging import getLogger, StreamHandler
+from typing import *
+
+from .__init__ import __version__, __title__
+from .exporter import PackageWriter
+from .model import HavingId
+from .parser.loader import *
+from .util.utils import list_pop_any
+
+JUSTIFICATION_SIZE = 140
+def get_logger(verbose: bool = False):
+    logger = getLogger('openapi-parser')
+    handler = StreamHandler(sys.stdout)
+    logger.addHandler(handler)
+    if (verbose):
+        handler.setLevel('DEBUG')
+        logger.setLevel('DEBUG')
+    else:
+        handler.setLevel('INFO')
+        logger.setLevel('INFO')
+    
+    return logger
+
+def run(schema_file: str, *writer_args, verbose: bool = False, dry_run: bool = False, clean: bool = True) -> int:
+    logger = get_logger(verbose=verbose)
+    
+    parser = OpenApiParser.open(schema_file)
+    parser.load_all()
+    
+    for path, mdl in parser.loaded_objects.items():
+        msg = ('# ' + type(mdl).__name__ + (f" '{mdl.id}'" if isinstance(mdl, HavingId) else '')).ljust(JUSTIFICATION_SIZE, ' ') + f" -- '{path}'"
+        logger.debug(msg)
+    logger.debug('# ' + '=' * JUSTIFICATION_SIZE)
+    logger.debug('')
+    
+    package_writer = PackageWriter(parser, *writer_args, dry_run=dry_run)
+    package_writer.write_package(clean=clean)
+    return 0
+
+def header_line() -> str:
+    return f"Python OpenAPI Parser Command-Line Interface v{__version__}"
+def version_line() -> str:
+    return f"{__title__} {__version__}"
+def usage_line() -> str:
+    return 'python -m openapi_parser SCHEMA [DESTINATION] [PACKAGE_NAME]'
+def usage_options() -> List[str]:
+    return \
+    [
+        "-v, --verbose | Enables extra verbosity",
+        "--dry-run     | Performs dry run (does not create any files)",
+        "--no-cleanup  | Does not perform cleanup before running",
+        "-h, --help -? | Print this message and exit",
+        "-V, --version | Print version and exit",
+    ]
+
+def cli(args: Optional[List[str]] = None) -> int:
+    if (args is None):
+        args = sys.argv[1:]
+    
+    if (len(args) < 1):
+        print(header_line(), file=sys.stderr)
+        print(f"Not enough arguments, usage: {usage_line()}", file=sys.stderr)
+        return 1
+    
+    help = bool(list_pop_any(args, '-h', '--help', '-?'))
+    if (help):
+        print(header_line())
+        print(f"Usage: {usage_line()}")
+        print()
+        print("Options:")
+        for opt in usage_options():
+            print(' '*4 + opt)
+        return 0
+    
+    version = bool(list_pop_any(args, '-V', '--version'))
+    if (version):
+        print(version_line())
+        return 0
+    
+    verbose = bool(list_pop_any(args, '-v', '--verbose'))
+    dry_run = bool(list_pop_any(args, '--dry-run'))
+    clean = not bool(list_pop_any(args, '--no-cleanup'))
+    schema_file = args.pop(0)
+    
+    return run(schema_file, *args, verbose=verbose, dry_run=dry_run, clean=clean)
+
+
+__all__ = \
+[
+    'cli',
+    'run',
+    'get_logger',
+    'usage_options',
+    'version_line',
+    'header_line',
+    'usage_line',
+    'JUSTIFICATION_SIZE',
+]
+__pdoc_extras__ = \
+[
+    'JUSTIFICATION_SIZE',
+]

openapi_parser-0.3.0/src/openapi_parser/exporter/__init__.py

@@ -0,0 +1,40 @@
+from .abstract_writer import *
+from .attribute_writer import *
+from .class_writer import *
+from .client_writer import *
+from .description_writer import *
+from .footer_writer import *
+from .header_writer import *
+from .inspect_writer import *
+from .method_writer import *
+from .model_writer import *
+from .package_writer import *
+from .utils_writer import *
+
+__all__ = [ ]
+
+_submodules = \
+[
+    abstract_writer,
+    attribute_writer,
+    class_writer,
+    client_writer,
+    description_writer,
+    footer_writer,
+    header_writer,
+    inspect_writer,
+    method_writer,
+    model_writer,
+    package_writer,
+    utils_writer,
+]
+
+__pdoc__ = { }
+for _submodule in _submodules:
+    _submodule_name = _submodule.__name__.partition(f'{__name__}.')[-1]
+    __all__.extend(_submodule.__all__)
+    __pdoc__[_submodule_name] = True
+    _submodule.__pdoc__ = getattr(_submodule, '__pdoc__', dict())
+    _extras = getattr(_submodule, '__pdoc_extras__', list())
+    for _element in _submodule.__all__:
+        __pdoc__[_element] = _element in _extras

openapi_parser-0.3.0/src/openapi_parser/exporter/abstract_writer.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import keyword
+import re
+from abc import ABC
+from dataclasses import dataclass
+from functools import wraps, partial
+from logging import Logger, getLogger
+from typing import *
+
+from openapi_parser.model import Model, Filter
+from openapi_parser.util._backports import singledispatchmethod
+from openapi_parser.util.naming_conventions import *
+from openapi_parser.util.typing_proxy import ref_name_pretty, class_name_pretty, GenericProxy, ref_name_logger
+from openapi_parser.util.utils import StrIO
+
+W = TypeVar('W', bound='Writer')
+class Writer(ABC):
+    JUSTIFICATION_SIZE = 80
+    INDENT_SIZE = 4
+    INDENT_SYMBOL = ' '
+    TRIPLE_QUOT = '"""'
+    TRIPLE_BACKQUOT = '```'
+    NEWLINE = '\n'
+    
+    _indent_level: int
+    logger: Logger
+    def __init__(self, *args, **kwargs):
+        self._indent_level = 0
+        self.logger = getLogger(ref_name_logger(type(self)))
+        super().__init__(*args, **kwargs)
+    
+    @property
+    def indent_level(self) -> int:
+        return self._indent_level
+    
+    @property
+    def indent_marker(self) -> str:
+        return self.INDENT_SYMBOL * self.INDENT_SIZE
+    
+    def indent(self, increment: int = 1) -> 'Indenting[W]':
+        return Indenting(self, increment)
+    
+    @classmethod
+    def class_name_pretty(cls, ref: Union[str, Type, GenericProxy, Model, Filter]) -> str:
+        if (isinstance(ref, str)):
+            return class_name(ref)
+        else:
+            return class_name_pretty(ref)
+    @classmethod
+    def package_name_pretty(cls, name: str) -> str:
+        return package_name(name)
+    @classmethod
+    def enum_entry_name_pretty(cls, name: str) -> str:
+        return enum_entry_name(name)
+    @classmethod
+    def field_name_pretty(cls, name: str) -> str:
+        return field_name(name)
+    @classmethod
+    def method_name_pretty(cls, name: str) -> str:
+        return method_name(name)
+    @classmethod
+    def const_name_pretty(cls, name: str) -> str:
+        return const_name(name)
+    @classmethod
+    def ref_name_pretty(cls, ref: Union[object, str], full: bool = False) -> str:
+        if (isinstance(ref, str)):
+            return ref
+        else:
+            return ref_name_pretty(ref, full=full)
+    @classmethod
+    def object_valid_name_filter(cls, name: str) -> str:
+        if (not re.fullmatch(r'\w+', name)):
+            name = re.sub(r'[\W_]+', '_', name).strip('_')
+        if (not name):
+            name += '_'
+        if (name[0].isdigit()):
+            name = 'OBJECT_' + name
+        if (name in keyword.kwlist):
+            name += '_'
+        
+        return name
+    @classmethod
+    def constructor(cls, prefix: str, *args, suffix: str = '', sep: str = '=', brackets: Tuple[str, str] = ('(', ')'), **kwargs) -> str:
+        return prefix + brackets[0] + ', '.join(list(args) + [ f'{k}{sep}{v}' for k, v in kwargs.items() ]) + brackets[1] + suffix
+    @classmethod
+    def dict_constructor(cls, **kwargs) -> str:
+        return cls.constructor('', sep=': ', brackets=('{', '}'), **{ repr(k): v for k, v in kwargs.items() })
+    def multiline_constructor(self, prefix: str, *args, suffix: str = '', sep: str = ' = ', brackets: Tuple[str, str] = ('(', ')'), **kwargs) -> Iterator[str]:
+        yield f'{prefix} \\'
+        yield brackets[0]
+        with self.indent():
+            for x in args:
+                yield f'{x},'
+            for k, v in kwargs.items():
+                yield f'{k}{sep}{v},'
+        yield brackets[1] + suffix
+    def smart_constructor(self, prefix: str, *args, suffix: str = '', **kwargs) -> Iterator[str]:
+        inline = self.constructor(prefix, *args, suffix=suffix, **kwargs)
+        if (len(inline) < 160):
+            yield inline
+        else:
+            yield from self.multiline_constructor(prefix, *args, suffix=suffix, **kwargs)
+    
+    @singledispatchmethod
+    def join_line(self, indent_level: int, line_text: str) -> str:
+        return self.indent_marker * indent_level + line_text
+    @join_line.register
+    def _(self, tup: tuple) -> str:
+        return self.join_line(*tup)
+    
+    def write_line(self, file: StrIO, line: str):
+        file.write(line)
+        file.write(self.NEWLINE)
+
+# noinspection PyProtectedMember
+@dataclass
+class Indenting(ContextManager, Generic[W]):
+    writer: W
+    increment: int = 1
+    
+    def __enter__(self):
+        self.writer._indent_level += self.increment
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.writer._indent_level -= self.increment
+
+def yielder(dumper_func: Callable[[W], Iterator[Optional[str]]]) -> Callable[[W], Iterator[Tuple[int, str]]]:
+    @wraps(dumper_func)
+    def wrapper(self: Writer, *args, **kwargs):
+        # noinspection PyArgumentList
+        return map(lambda line: (self.indent_level, line or ''), dumper_func(self, *args, **kwargs))
+    return wrapper
+
+def writer(yielder_func: Callable[[W], Iterator[Tuple[int, str]]]) -> Callable[[W], Optional[Iterator[str]]]:
+    @wraps(yielder_func)
+    def wrapper(self: Writer, *args, file: StrIO | None = None, **kwargs):
+        # noinspection PyArgumentList
+        stream = map(self.join_line, yielder_func(self, *args, **kwargs))
+        if (file is not None):
+            list(map(partial(self.write_line, file), stream))
+        else:
+            return stream
+    
+    return wrapper
+
+
+__all__ = \
+[
+    'Indenting',
+    'Writer',
+    
+    'writer',
+    'yielder',
+]

openapi_parser-0.3.0/src/openapi_parser/exporter/attribute_writer.py

@@ -0,0 +1,75 @@
+from abc import ABC
+from typing import *
+
+from functional import OptionNone, Some, Option
+
+from openapi_parser.model import ModelSchema
+from openapi_parser.util.typing_proxy import GenericProxy
+from .abstract_writer import Writer
+
+class AttributeWriter(Writer, ABC):
+    def parse_attribute(self, name: str, prop: Optional[ModelSchema], *, is_required: bool = True) -> Tuple[str, Option[str], Option[str], Option[str]]:
+        field_name_pretty = self.field_name_pretty(name)
+        actual_name = self.object_valid_name_filter(field_name_pretty)
+        
+        if (prop is None):
+            f_type = Some('Optional[Any]') if (not is_required) else OptionNone
+            f_value = Some('None') if (not is_required) else OptionNone
+            f_default = Some('None') if (not is_required) else OptionNone
+        
+        else:
+            if (prop.cls == Any):
+                f_type = OptionNone
+            else:
+                f_type = Some(self.class_name_pretty(prop.cls)) if isinstance(prop, ModelSchema) else OptionNone
+            f_default = prop.default
+            
+            # for enum in find_filters(prop.filter, ModelEnumData):
+            #     f_type = Some(self.object_valid_name_filter(self.class_name_pretty(enum)))
+            
+            if (not is_required):
+                f_type = f_type.map('Optional[{}]'.format)
+                f_default = f_default or (Some(None) if (not is_required) else OptionNone)
+            
+            f_value = f_default.map('{!r}'.format)
+        
+        return actual_name, f_type, f_value, f_default
+    
+    def join_attribute(self, actual_name: str, f_type: Option[str], f_value: Option[str]) -> str:
+        return actual_name + f_type.map(': {}'.format).get_or_else('') + f_value.map(' = {}'.format).get_or_else('')
+    
+    def extract_generic_coder(self, generic: GenericProxy, coder_type: str) -> Optional[str]:
+        parsed = generic.deep_coder(coder_type)
+        if (parsed is None):
+            return None
+        
+        return 'lambda x: ' + self._extract_generic_coder('x', *parsed)
+    
+    def _extract_generic_coder(self, super_var: str, gen: GenericProxy, params: Dict[str, Optional[Union[Tuple, Callable, str, None]]]) -> str:
+        items = list()
+        for var, coder in params.items():
+            if (coder is None):
+                coder = var
+            elif (isinstance(coder, tuple)):
+                coder = Option(self._extract_generic_coder(var, *coder)).map(lambda x: x + f'({var})').get_or_else(var)
+            else:
+                coder = self.ref_name_pretty(coder)
+            
+            items.append(coder)
+        
+        return gen.constructor(f"{gen.item_constructor(tuple(items))} for {', '.join(params.keys())} in {gen.iterator(super_var)}")
+    
+    def extract_coder(self, prop: ModelSchema, coder_type: str) -> Optional[str]:
+        coder = getattr(prop.filter, coder_type)
+        if (coder is not None):
+            return self.ref_name_pretty(coder)
+        elif (isinstance(prop.cls, GenericProxy)):
+            return self.extract_generic_coder(prop.cls, coder_type)
+        else:
+            return None
+
+
+__all__ = \
+[
+    'AttributeWriter',
+]