# packages

pkgId: 521fdca77190c511b4663a0c4171b3ea374293b8615fe3034800e5746f618fbc
name: python-cobble
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Create data objects
url: http://github.com/mwilliamson/python-cobble
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobble-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Cobble is a Python library that allows easy creation of data objects,
  including implementations of common methods such as ``__eq__`` and ``__repr__``.


pkgId: 77baa82885f407225baf92d66ee3c902b28c79d85a3ad681eff168e27e9ef160
name: python-cobib
arch: src
version: 5.2.1
epoch: 0
release: 1
summary: Console Bibliography
url: https://gitlab.com/cobib/cobib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobib-5.2.1-1.src.rpm
checksum_type: sha256
description:
  [![coBib](https://gitlab.com/cobib/cobib/-/raw/master/logo/cobib_logo.svg)](https://cobib.gitlab.io/cobib/cobib.html)



  [![pipeline](https://gitlab.com/cobib/cobib/badges/master/pipeline.svg)](https://gitlab.com/cobib/cobib/-/pipelines)
  [![coverage](https://gitlab.com/cobib/cobib/badges/master/coverage.svg)](https://gitlab.com/cobib/cobib/-/graphs/master/charts)
  [![PyPI](https://img.shields.io/pypi/v/cobib)](https://pypi.org/project/cobib/)

  coBib is a simple, command-line based bibliography management tool.
  It is the result of the need for an easy-to-use alternative to full-blown reference managers like Mendeley or Zotero.
  As such it follows some basic design goals:

  * **plain-text database**: which means you get full access and control over the database.
  * **git-integration**: as a benefit of the above, you can keep track of your database through version control.
  * **centralized database, location-independent library**: this means, that coBib *only* manages the
    database file in a centralized fashion but allows you to spread the actual contents of your
    library across the entire file system (this is the major different to
    [papis](https://papis.readthedocs.io/en/latest/library_structure.html)).
  * **command-line and TUI support**: all features are available through the command-line as well as a
    [textual](https://textual.textualize.io/)-based TUI




  For all common purposes you can install coBib via `pip`:

  ```
  pip install cobib
  ```

  Note: Use `pip3` if you still have Python 2 installed.

  If you would also like to install the man-page, you need to download the source
  code and do the following:

  ```
  git clone https://gitlab.com/cobib/cobib
  cd cobib
  make install_extras
  ```



  coBib is packaged in the AUR.
  * [cobib](https://aur.archlinux.org/packages/cobib/)
  * [cobib-git](https://aur.archlinux.org/packages/cobib-git/)



  coBib _might_ work on Windows as is, but it is not being tested so no guarantees are given.
  If you are using Windows 10 or later and are running into issues, you should be able to install and
  use coBib's full functionality within the Linux subsystem.




  To get started, you must initialize the database:

  ```
  cobib init
  ```

  If you would like to enable the git-integration, you should run:

  ```
  cobib init --git
  ```

  *and* enable `config.database.git` (see also [configuration](#configuration)).

  Be sure to check out my [Quickstart blog post](https://mrossinek.gitlab.io/programming/introducing-cobib/)
  for a more guided introduction compared to the following section!



  coBib provides an `import` command through which you can easily import your library
  from another bibliography manager. For more details check out:

  ```
  cobib import --help
  ```

  So far, coBib knows how to import your library from Zotero by simply running:

  ```
  cobib import --zotero
  ```

  Check out the following command, the man page or the online documentation for more details:

  ```
  cobib import --zotero -- --help
  ```





  You can now add new entries to your database (see also `cobib.commands.add`[^1]):

  ```
  cobib add --bibtex some_biblatex_file.bib
  cobib add --arxiv <some arXiv ID>
  cobib add --doi <some DOI>
  cobib add --isbn <some ISBN>
  ```

  **Note**: when adding data from a `.bib` file, make sure that it is in the Bib**La**Tex format!



  You can view the contents of your database with (see also `cobib.commands.list_`):

  ```
  cobib list
  ```

  You can show a specific entry with (see also `cobib.commands.show`):

  ```
  cobib show <some entry label>
  ```

  You can open an associated file of an entry with (see also `cobib.commands.open`):

  ```
  cobib open <some entry label>
  ```

  You can even search through your database with (see also `cobib.commands.search`):

  ```
  cobib search "some text"
  ```



  You can delete an entry with (see also `cobib.commands.delete`):

  ```
  cobib delete <some entry label>
  ```

  You can edit an entry manually with (see also `cobib.commands.edit`):

  ```
  cobib edit <some entry label>
  ```

  You can also apply simple modifications to multiple entries at once with (see also
  `cobib.commands.modify`):

  ```
  cobib modify tags:private -- <some entry label> <another entry label> ...
  ```



  You can export your database with (see also `cobib.commands.export`):

  ```
  cobib export --bibtex my_bibliography.bib
  cobib export --zip my_library.zip
  ```



  If you have enabled the git-integration, you can undo and re-apply changes to your database with
  (see also `cobib.commands.undo` and `cobib.commands.redo`):

  ```
  cobib undo
  cobib redo
  ```



  Each subcommand provides additional help via:

  ```
  cobib <subcommand> --help
  ```

  and you can find extensive information in the online documentation (linked above) and the man-page:

  ```
  man cobib
  ```



  Finally, you can also use coBib's TUI for a more interactive experience (see also `cobib.ui.tui`),
  by simply typing
  ```
  cobib
  ```

  Here is an example screenshot of the TUI when listing the entries in your database:

  ![coBib TUI List](https://gitlab.com/cobib/cobib/-/raw/master/html/cobib_tui_list.svg)

  And here is an example screenshot for listing search results:

  ![coBib TUI Search](https://gitlab.com/cobib/cobib/-/raw/master/html/cobib_tui_search.svg)




  You can overwrite the default configuration by placing a `config.py` file in `~/.config/cobib/`.
  The easiest way to get started with this file is by copying [`example.py`](https://gitlab.com/cobib/cobib/-/blob/master/src/cobib/config/example.py)
  or by using:

  ```
  cobib _example_config > ~/.config/cobib/config.py
  ```

  You can then modify it to your liking.

  You may also specify a different config file at runtime by using the `-c` or `--config` command line argument or by specifying a custom path in the `COBIB_CONFIG` environment variable.
  You can also disable loading of _any_ configuration file be setting this environment variable to one of the following values: `"", 0, "f", "false", "nil", "none"`.

  Finally, be sure to take a look at the man page (`man cobib`) and/or the online documentation for more information.




  coBib supports the implementation of plugins!
  You can find an example plugin in [this folder](./plugin) or read the docs of
  `cobib_dummy` (when viewing the hosted documentation online).




  coBib's documentation is hosted [here](https://cobib.gitlab.io/cobib/cobib.html).

  If you would like to generate a local version during development, you need to clone the source code, and install [`pdoc`](https://github.com/mitmproxy/pdoc) in order to generate it:

  ```
  git clone https://gitlab.com/cobib/cobib.git
  cd cobib
  pip install pdoc
  pdoc -d google -e cobib=https://gitlab.com/cobib/cobib/-/blob/master/src/cobib/ -t html -o docs src/cobib tests
  ```

  You can then browse the documentation from `docs/cobib.html`.




  I have started this project when I was looking into alternatives to popular reference managers such as Mendeley,
  which has more features than I use on a regular basis and does not allow me to work from the command line which is where I spent most of the time that I spent on the computer.

  Hence, I have decided to make it my own task of implementing a simple, yet fast, reference manager.
  coBib is written in Python and uses a YAML file to store its bibliography in a plain text format.



  You can find the detailed changes throughout coBib's history in [the Changelog](https://gitlab.com/cobib/cobib/-/blob/master/CHANGELOG.md).




  coBib is licensed under the [MIT License](https://gitlab.com/cobib/cobib/-/blob/master/LICENSE.txt).

  [^1]: References like this one get interpreted by the documentation generator. If you are reading this as the README page, you may find the [online documentation](https://cobib.gitlab.io/cobib/cobib.html) more enjoyable.

  [//]: # ( vim: set ft=markdown: )


  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).






  Pypi: https://pypi.org/project/cobib/5.2.1/



  - compatibility with `textual>=0.80`




  Pypi: https://pypi.org/project/cobib/5.2.0/



  With the addition of the new `note` command, the database entry fields called
  `"note"` have obtained a special meaning. Use the `lint` command to check
  whether your database is affected by this. If it is, you should rename those
  fields.


  - new configuration settings to customize the appearance of coBib (!222):
    - `cobib.config.theme.dark`: to specify whether a dark or light theme is used
    - `cobib.config.theme.design`: to customize the colors themselves
    - the following settings to customize the appearance of `rich.Syntax` displays:
      - `cobib.config.theme.syntax.theme`
      - `cobib.config.theme.syntax.background_color`
      - `cobib.config.theme.syntax.line_numbers`
  - the `note` command (#139,!206).
    Please refer to its online documentation or the man-page for more details on
    how to use it.
    This new command comes with:
    - the `cobib.config.commands.note.default_filetype` setting
    - the `PreNoteCommand` and `PostNoteCommand` event hooks
  - (DEV) the `add_files` argument to the `BaseCommand.git` function
  - Python 3.13 is now officially tested and supported
  - new configuration settings for the search command (#146,!269)
    - For dealing with skipping/including associated files during searches:
      - `cobib.config.commands.search.skip_files` sets the default
      - `--skip-files` overwrites this at runtime (this is not actually new)
      - `--include-files` overwrites this at runtime (the opposite)
    - For dealing with skipping/including associated notes during searches:
      - `cobib.config.commands.search.skip_notes` sets the default
      - `--skip-notes` overwrites this at runtime (this is not actually new)
      - `--include-notes` overwrites this at runtime (the opposite)


  - the keybinding to recursively toggle all folds in the TUI's search result view
    was changed from `ENTER` to `BACKSPACE` (!218)
  - (DEV) `cobib.ui.components.entry_points` was moved to `cobib.utils.entry_points`
  - replaced the custom help screen with textual's new builtin help panel (!240)


  - the behavior of the `Home` and `End` keybindings in the TUI's list view (!217)
  - gracefully handles Zotero imported entries without a `journal` field (#145)




  Pypi: https://pypi.org/project/cobib/5.1.3/


  - the behavior of the `Home` and `End` keybindings in the TUI's list view (!217)




  Pypi: https://pypi.org/project/cobib/5.1.2/


  - support database locations in nested folders of a git repository (!204)




  Pypi: https://pypi.org/project/cobib/5.1.1/



  - when printing the changelog, do not remove list indents




  Pypi: https://pypi.org/project/cobib/5.1.0/



  Check out my blog post to learn more about the features of this new release:
  https://mrossinek.gitlab.io/programming/cobib-becomes-fuzzy/


  - approximate (or fuzzy) filter matching and search functionality (#107,#130,!177)
    - the `list` and `search` commands now support the following features to
      perform approximate filter matching and searching, respectively:
      - LaTeX sequences can be decoded to Unicode characters:
        - using `--decode-latex` from the command-line
        - setting `config.commands.list_.decode_latex = True`
        - setting `config.commands.search.decode_latex = True`
      - Unicode characters can be converted to a close ASCII equivalent:
        - using `--decode-unicode` from the command-line
        - setting `config.commands.list_.decode_unicode = True`
        - setting `config.commands.search.decode_unicode = True`
      - a number of fuzzy errors can be set (this requires the optional dependency
        [`regex`](https://pypi.org/project/regex/) to be installed):
        - using `--fuzziness <int>` from the command-line
        - setting `config.commands.list_.fuzzines` to some integer
        - setting `config.commands.search.fuzzines` to some integer
  - (DEV) the following method arguments have been converted to be accepted only
    as keyword arguments:
    - in `cobib.database.Entry.matches`: `ignore_case`
    - in `cobib.database.Entry.search`: `context`, `ignore_case`, and `skip_files`
  - (DEV) the return-type of `cobib.database.Entry.search` has been changed




  Pypi: https://pypi.org/project/cobib/5.0.1/


  - the ability to use an empty string as the separator in `config.database.format.label_suffix` (#138)




  Pypi: https://pypi.org/project/cobib/5.0.0/



  - the ability to add custom `commands`, `importers`, and `parsers` through entry points (#135, !139)
    - (DEV) a dummy plugin show-casing these extensions


  - the entire `shell_helper` module has been replaced as follows (!139):
    - the following deprecated helper methods were removed without replacement:
      - `_list_commands`
      - `_list_filters`
      - `_list_labels`
    - the following secondary commands have been refactored:
      - `_lint_database` is now `cobib.commands.lint.LintCommand`
      - `_unify_labels` is now `cobib.commands.unify_labels.UnifyLabelsCommand`
      - `_example_config` is now `cobib.config.command.ExampleConfigCommand`
  - the interactive disambiguation mechanism during the `add` command now handles
    multiple matching related entries (#121,!168)
    - this includes the ability to `cancel` the disambiguation and entry addition



  - the previously deprecated `console` attribute of all commands has been removed (!139)
  - the previously deprecated `prompt` attribute of all commands has been removed (!139)
  - the `cobib.ui.shell_helper` and `cobib.utils.shell_helper` modules have been removed (!139)
  - the previously deprecated `--update` argument of the `add` command (!168)
  - the previously deprecated `--skip-existing` argument of the `add` command (!168)
  - the previously deprecated `LabelSuffix.CAPTIAL` attribute (!168)
  - Python 3.8 is no longer supported (!173)




  Pypi: https://pypi.org/project/cobib/4.5.0/


  - the new `cobib.utils.context.get_active_app` method which returns any running
    textual App and replaces the need for the `cobib.utils.prompt.Prompt.console`
    and `cobib.utils.progress.Progress.console` (which have been removed) (!137)
  - `cobib.parsers.YAMLParser.parse` can now also parse strings directly (rather
    than always interpreting the argument as the path to a file) (!137)
  - the `review` command (#131,!137).
    Please refer to its online documentation or the man-page for more details on
    how to use it.
  - the `cobib.database.Entry.merge` method (!137)


  - log messages will now be displayed in the `LogPanel` of the TUI (which can be
    toggled with the `z` keybinding) (#132,!133)
  - the `cobib.ui.components.prompt` module has been refactored into `cobib.utils.prompt` (!133)


  - the `console` argument to all commands has been deprecated since it no longer
    has any effect (!133)
  - the `prompt` argument to all commands has been deprecated since it no longer
    has any effect (!133)
  - access to the following `shell_helper` commands will change in the next release:
    - `cobib _lint_database` will become `cobib lint`
    - `cobib _unify_labels` will become `cobib unify_labels`
    - `cobib _example_config` will become `cobib example_config`


  - loading a cached database will be bypassed during `_lint_database` (#133)
    - to support this the `bypass_cache` keyword-argument was added to the
      `Database.read` method


  - official Windows support label. It _might_ work but no guarantees are made (#136)




  Pypi: https://pypi.org/project/cobib/4.4.0/


  - a primitive caching mechanism to speed up the database loading. This feature
    is enabled by default and will store its cache at `~/.cache/cobib/databases/`.
    You can configure the location via `config.database.cache` or even disable
    caching entirely by changing this setting to `None`. (see also #129 and !108)
  - added the `-r/--remove` option to the `modify` command (#128)
    - this can achieve the opposite of `-a/--add` in the sense that it will try to
      remove the specified modification from a list or subtract a number from
      numeric values
    - other field types than lists or numbers are not supported by this option
  - added the `-l/--limit` option to the `list` command (#127)
    - exposed the `ListCommand.sort_entries` method in the public API
    - added the `ListCommand.execute_dull` method in the public API
  - the `search`, `export`, and `modify` commands now also support sorting and limiting options to be
    passed onto the `list` command (along with the already existing filtering options)
  - the `config.tui.tree_folding` setting which allows you to configure the
    default folding state of the tree nodes in the TUI's search result view
  - the `ENTER` binding in the TUI's search result view to recursively toggle all
    folds of the current node


  - when using the TUI you may now use the `:show <label>` command to jump to the
    specified label (#126,!116)
  - the `search` command now reports its progress live (!117)


  - unblocked the vertical scrollbar of the TUI's list view from the scroll offset




  Pypi: https://pypi.org/project/cobib/4.3.1/


  Note, that the introduction of the detailed author information parsing in v4.3.0
  resulted in possible breaking of a custom `config.database.format.label_default`
  setup. This bugfix release is meant to emphasize this breaking change and
  updates the documented example in the example configuration file. For the sake
  of verbosity, here is the change applied to the example:

  - old: `"{unidecode(author.split(' and ')[0].split()[-1])}{year}"`
  - new: `"{unidecode(author[0].last)}{year}"`




  Pypi: https://pypi.org/project/cobib/4.3.0/




  coBib now has the ability to store more detailed author information (see #92 and
  !88). This means, that the `author` field of an entry is analyzed in more detail
  and coBib will separate out the first and last names as well as name pre- and
  suffixes. The new setting `config.database.format.author_format` determines,
  whether this detailed information is kept directly in the database (the
  `AuthorFormat.YAML` setting; the **new default**) or is only constructed at
  runtime and the author field is still simply saved in BibLaTeX form
  (`AuthorFormat.BIBLATEX`).

  Note, that the `YAML` format also implies, that Unicode characters are allowed
  and will *not* be encoded in LaTeX form. This has an effect on how you may need
  to format your searches. See also #130 for some more insights on this.

  If you have company names or any author name which you want to have treated
  verbatim, you can simply wrap it in curly braces (e.g. `{My Company}`).
  Refer to the online documentation of `cobib.database.Author` and the above
  setting for more details.


  coBib now has a [Wiki](https://gitlab.com/cobib/cobib/-/wikis/home) where we can
  gather useful configuration resources and other details which may not make it
  into the full documentation.

  For example, if you are interested in the tracking more metadata of your
  database (as suggested in #123), be sure to check out
  [this wiki page](https://gitlab.com/cobib/cobib/-/wikis/Useful-Event-Hooks)!


  - the `-f` short-hand alias for the `--field` argument of the `open` command
  - the `opened_entries` attribute of the `OpenCommand` (which is accessible during the `PostOpenCommand` hook)
  - the new `git` command to simplify running git operations on the database (#124)
  - new bindings for `Home`, `End`, `PageUp`, and `PageDown` in the TUI
  - (DEV) added a new `DEPRECATED` logging level which has value 45
  - Python 3.12 is now officially tested and supported
  - the `config.commands.show.encode_latex` setting
  - the `encode_latex` attribute to the `BibtexParser`
  - the `config.database.format.verbatim_fields` setting
  - the `config.database.format.author_format` setting. The new default behavior
    is to store detailed author information in YAML form.
  - the `encode_latex` keyword-argument to the `Entry.stringify` method
  - the `Entry.formatted` method. This replaces the `Entry.escape_special_chars` method.


  - an error will be logged when a file is not found during the `open` command
  - the following commands are now treated specially when run via the `:` prompt of the TUI:
    - `init`: will log an error
    - `git`: will log an error
    - `show`: will log a warning


  - The `LabelSuffix.CAPTIAL` value because it was misspelled. Please use `LabelSuffix.CAPITAL` instead.


  - non-asynchronous commands triggered via the `:` prompt of the TUI will no longer break it (#125)
  - ensure UTF-8 encoding is used for downloaded data (this fixes many odd encounters w.r.t. special characters)
  - the spelling of the `LabelSuffix.CAPITAL` value (it used to be spelled `LabelSuffix.CAPTIAL`)


  - the `Entry.escape_special_chars` method. Use `Entry.formatted` instead.




  Pypi: https://pypi.org/project/cobib/4.2.0/


  - added the `config.tui.scroll_offset` setting
  - added the `--field` command line option to the `open` command
  - (DEV) added a new `HINT` logging level which has value 35 and thus allows to
    provide information to the user with a higher priority than `WARNING`
  - added the new `config.tui.preset_filters` (#114)
    - preset filters can be selected from the TUI via the `p` key binding
    - the first 9 filters can be selected directly by pressing the respective number
    - pressing `0` resets any applied filter
  - implemented special tags (#63,!83)
    - adds new builtin tags which will trigger special highlights of entries: `new`, `high`, `medium`, `low`
    - adds the new `config.theme` settings section for configuring these settings
    - you can also add more special tags via `config.theme.tags.user_tags`
  - added the `--skip-files` command line option to the `search` command


  - unicode symbols in entry labels will now be replaced with ascii ones (#119,#120)
    - this is configured via the `config.database.format.default_label` setting, so if you are using a
      custom value for this, be sure to update your config to make use of this feature
  - some user-visible logging messages around label disambiguation have been added (see also #121)
  - a warning has been added when the YAML parser encounters identical labels (which normally should
    not occur in the database but if it does, coBib does not really know how to resolve this)
  - DOI redirect links are now followed recursively (up to 3 times), improving PDF
    download link detection in the process (#97)


  - the `config.commands.search.highlights` section is deprecated in favor of `config.theme.search`


  - retain scroll position in the TUI's list view




  Pypi: https://pypi.org/project/cobib/4.1.0/


  - added the following settings which specify whether or not to preserve
    associated files during the respective commands being run:
    - `config.commands.delete.preserve_files`
    - `config.commands.edit.preserve_files`
    - `config.commands.modify.preserve_files`
  - added a confirmation prompt before deleting an entry (#110)
    - this prompt can be disabled by setting `config.commands.delete.confirm` to `False`
  - added the `--no-ignore-case` (`-I` for short) command line options to the
    `list` and `search` command (#116)
  - added the `--no-preserve-files` command line options to the `delete`, `edit`
    and `modify` command (#116)
  - added the `config.commands.search.context` setting which configures the
    default number of context lines to be provided for search query matches
  - added more options to configure the automatic download behavior:
    - the new `config.commands.add.skip_download` setting
    - the new `--force-download` option of the `add` command
    - the new `config.commands.import_.skip_download` setting
    - the new `--force-download` option of the `import` command
  - the user is asked for confirmation when quitting the TUI (!71)


  - refactored the TUI by leveraging textual's `Screen` concept (#111,!71)
    - this means the TUI will look slightly different but no real functional change has occurred
    - the view of an `Entry` can now be scrolled when the output exceeds the available space
  - switched from the `BeautifulSoup` HTML parser to `lxml`
    - this is supposed to give more accurate results but adds an extra dependency


  - The following shell helpers are no longer used with the zsh completion being
    removed. Thus, these methods will be removed in the future:
    - `cobib _list_commands`
    - `cobib _list_filters`
    - `cobib _list_labels`
    - If you see warnings because of this while you are using the CLI, you
      probably still have the (now removed) zsh completion script installed. You
      should remove the `_cobib` file which will be located in one of the
      directories listed in your `$FPATH` environment variable.


  - the proper pre-population of the TUI prompt during the sorting action (#117)
  - preserves the value of `config.commands.list_.default_columns` and
    properly removes a field if it is no longer sorted by in the TUI (#117)
  - properly updates the list of entries in the TUI after changing the database contents;
    for example via `add` (#113) or `delete` (#113) or `edit` (#118)
  - an issue where file-accessing operations performed on a newly added entry within
    the same TUI session would fail because the path would not be iterated correctly
  - the live updating of the download progress bar inside the TUI (#112)


  - the crude and very slow zsh completion script




  Pypi: https://pypi.org/project/cobib/4.0.0/


  - Configuration settings can no longer be set by item access and instead must
    use attribute syntax. For example you need to change:
    ```python
    config["database"]["git"] = True
    ```
    to
    ```python
    config.database.git = True
    ```
    - the `config.commands.list` section had to be renamed to `config.commands.list_`
    - the `config.tui` section has been entirely removed
  - The `cobib.commands.list` module was moved to `cobib.commands.list_`.
  - The function signature of all command- and importer-related events has changed!
    For more details please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html).


  - Python 3.11 is now officially tested and supported
  - Full rewrite of all commands to use `rich` for a nicer CLI (#78,!51)
  - Full rewrite of the TUI based on `textual` (#78,!51)
  - the `--disambiguation` argument of the `add` command (#99,!58)
  - the `--ignore-case` argument of the `list` command (#105)
    - this also comes with the new `config.commands.list_.ignore_case` setting
  - the `search` command now accepts multiple query strings at once which will be
    searched over independently (#106)


  - the new default value of `config.parsers.yaml.use_c_lib_yaml` is now `True` as announced in version [3.4.0]
  - refactored the entire config as a dataclass (!63)
    - this implies that settings can only be set via attributes
    - but as a benefit the maintainability and documentation have improved significantly
  - The function signature of all command-related events has changed! Please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)
    for more details. (!63)
  - The function signature of all importer-related events has changed! Please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)
    for more details. (!66)
  - the API of the `cobib.commands` and `cobib.importers` module has been improved (!64)
    - this should not have any end-user facing effects
  - the `cobib.commands.list` module was moved to `cobib.commands.list_`


  - the `--update` argument of the `add` command is deprecated in favor of `--disambiguation update`
  - the `--skip-existing` argument of the `add` command is deprecated in favor of `--disambiguation keep`


  - the detection whether an entry already exists broke when label disambiguation was added in [3.3.0]
    and is now fixed by means of an interactive prompt during the `add` command


  - the warning triggered upon setting `config.database.format.month` which got removed in [3.1.0]
  - Python 3.7 is no longer supported




  Pypi: https://pypi.org/project/cobib/3.5.5/


  - opening of non-list type fields (#100)




  Pypi: https://pypi.org/project/cobib/3.5.4/


  - missing files encountered during searching will log warnings gracefully instead of harshly
  - handle newline characters in the TUI (#98)




  Pypi: https://pypi.org/project/cobib/3.5.3/


  - incorrect author concatenation in ISBN Parser
  - using the disambiguated label for the names of downloaded files (#96)




  Pypi: https://pypi.org/project/cobib/3.5.2/


  - run TUI on BSD platforms (!52)




  Pypi: https://pypi.org/project/cobib/3.5.1/


  - safely check cache existence before attempting to write (#94)




  Pypi: https://pypi.org/project/cobib/3.5.0/


  The plan is to switch to [rich][rich] and [textual][textual] instead of the current curses TUI.
  This will open up some great possibilities for a much more modern UI.

  However, this change will require some *major* refactoring including breaking changes of the API
  and some of the user configuration options. It will also be a rather drastic change in style.
  Thus, I will attempt to support v3.5 with bugfix releases until 1.1.2023

  It will likely take a few months until v4.0 gets released but I am starting development on it now.
  You can follow the progress here: <https://gitlab.com/cobib/cobib/-/issues/78>

  [rich]: https://github.com/Textualize/rich
  [textual]: https://github.com/Textualize/textual


  - the configuration loading can be disabled via the environment variable `COBIB_CONFIG`
      - values which disable the loading entirely are: `"", 0, f, false, nil, none`
      - you can also specify a custom path to a configuration file in this variable


  - the `INI`-style configuration got fully removed (as deprecated in [3.0.0] - 2021-04-10)




  Pypi: https://pypi.org/project/cobib/3.4.0/

  - coBib now requires the `requests-oauthlib` package
      - technically this is an optional dependency for now, but it will likely become a requirement soon


  - the new `config.parsers.yaml.use_c_lib_yaml` setting which significantly improves loading performance
      - this setting will change its default value to `True` in version 4.0.0
  * the `Import` command (#86,!49):
      - can be used to import libraries from other bibliography managers (see next bullet)
      - see `cobib import --help` for more information
  - the `cobib.importers` module:
      - provides importer classes for various other bibliography managers
      - these get registered at runtime under the `cobib import` command
      - this release provides the `--zotero` importer
      - see `cobib import --zotero -- --help` for more information
  - the `config.logging.cache` option, specifying the location of a simple json cache
  - the `config.commands.open.fields` option, specifying the names of the data fields which are checked for openable URLs (#89)


  - the `PreFileDownload` event now takes an additional argument: `headers: Optional[Dict[str, str]]`


  - downloaded file names will not duplicate the `.pdf` suffix




  Pypi: https://pypi.org/project/cobib/3.3.2/


  - re-enable the terminal keypad during resize event
      - this ensures proper arrow-key behavior after returning from an external editor
  - clear screen after closing TUI to remove all screen artifacts


  - remove warning when using the DOI parser because the upstream issue related to #91 got fixed




  Pypi: https://pypi.org/project/cobib/3.3.1/


  - erroneous label disambiguation of Entry labels which already conform with `config.database.format.default_label_format` (#87,!47)
  - do not add empty file list when unifying database


  - log warning when using the DOI parser because of (#91)




  Pypi: https://pypi.org/project/cobib/3.3.0/


  - print Changelog since the last run version (cached in `config.logging.version`) (#82)
  - the `AddCommand` now has a new `--update` option (#79,!41)
  - the `_lint_database` utility now takes the `--format` argument, which automatically resolves all lint messages (#81,!42)
  - the new `URLParser` (available via `cobib add --url <URL>` (#84,!44)
      - it attempts importing from a plain URL
      - simultaneously the arXiv, DOI, and ISBN parsers now also support URL containing a matching identifier directly
  - the `--dry` argument of the `ModifyCommand` to prevent errors during large bulk modifications
  * the `config.database.format.label_default` and `config.database.format.label_suffix` options (#85,!45)
      - labels will automatically be formatted according to the default option
      - if labels conflict with existing ones, the suffix option will be used for disambiguation
      - the `AddCommand` has a new `--skip-existing` option which disables automatic label disambiguation
      - use `cobib _unify_labels --apply` to unify all labels in your database
  - subscribable events (#71,!46)
      - allows registering of hooks to be executed in certain situation
      - more information is provided at the [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)


  - when an unknown variable is encountered in the modification of the `modify` command it falls back to an empty string rather than the name of the attempted variable


  - the `-s` option of the `AddCommand` is no longer available. You need to write out `--skip-download`
  - the `ID` filter argument on the `list` command (deprecated in v3.2.0 in favor of the `label` filter)




  Pypi: https://pypi.org/project/cobib/3.2.1/


  - when adding multiple entries at once, continue adding after encountering a single duplicate (#83)




  Pypi: https://pypi.org/project/cobib/3.2.0/


  - basic auto-downloading of PDF files for arXiv IDs and configured DOIs (#25,!35,!39):
      - the default download location can be configured via `config.utils.file_downloader.default_location`
      - on a per addition basis, this default can be overwritten via the `--path` keyword option of the `AddCommand`
      - if a file already exists in this location of the file system, the download will be skipped
      - download for DOI entries must configure URL patterns in `config.utils.file_downloader.url_map`
      - on a per addition basis, the entire automatic download can be skipped with `--skip-download`
  - automatic journal abbreviations (#62,!36):
      - users can configure a list of journal abbreviations via `config.utils.journal_abbreviations`
      - if present, coBib will store the journal in its elongated form
      - a user can then automatically convert to abbreviated forms during exporting (see the new `--abbreviate` and `--dotless` arguments)
  - Tentative Windows support by disabling the TUI
  - a `--preserve-files` argument was added to the following commands. Unless it is given, these will delete/rename associated files of affected entries:
      - `DeleteCommand`
      - `EditCommand`
      - `ModifyCommand`


  - the `modifications` of a `ModifyCommand` get interpreted as f-strings (#77,!37):
      - available variables are the entry's label and data fields
  - any `ListCommand` filter gets interpreted as a regex pattern (#76)


  - the `ID` filter argument was fully replaced by `label`, unifying the CLI API. Support will be dropped in v3.3.0


  - Removed (most) duplication of log messages




  Pypi: https://pypi.org/project/cobib/3.1.1/


  - Pypi package metadata




  Pypi: https://pypi.org/project/cobib/3.1.0/


  - the YAML format of the database has been extended to support the following: (#55)
      - numbers can be stored as integers
      - the `ID` field is no longer required and will be properly inferred from the label
      - the following fields can be stored as lists: `file`, `tags`, `url`
  - three new configuration options were added to complement the above list format options:
      - `config.database.stringify.list_separator.file`
      - `config.database.stringify.list_separator.tags`
      - `config.database.stringify.list_separator.url`
  - the `_lint_database` shell utility has been added which can be used to detect possible improvements for the database
  - the append-mode of the `ModifyCommand` was implemented (#60):
      - specifying `-a`/`--add` will add the modification value to the field of the entries rather than overwrite it
      - this can be used for string or list concatenation and even number addition on numeric fields


  - use file paths relative to user-home (achieved by replacing `os.path` with `pathlib`) (#69)
  - the shell helper `_list_tags` has been renamed to `_list_labels`
  - (DEV): the `logging` and `zsh_helper` modules have been relocated to the `cobib.utils` package
  - `+` symbols will no longer be stripped from tags (this was a left-over artifact from pre-v1.0.0)


  - the `config.database.format.month` setting is deprecated in favor of proper three-letter code encoding to support common citation style macros (!34)


  - renaming the label during the `edit` command does not leave the previous label entry behind:
      - a followup also ensured that renaming entries happens in-place (#75)
  - the sorting of the `list` command




  Pypi: https://pypi.org/project/cobib/3.0.0/

  - From now on, `coBib` is the official way of spelling!


  - coBib's documentation is now generated by [`pdoc`](https://pdoc.dev/) and hosted at https://cobib.gitlab.io/cobib/cobib.html
  - (DEV): the `cobib.database.Database`-Singleton has been added to centrally manage the bibliographic runtime data (!28)
  - the new option `config.database.format.suppress_latex_warnings`
  - the new option `config.commands.edit.editor` which takes precedence over the `$EDITOR` variable


  - the `INI`-style configuration is replaced with a `Python`-based configuration (#54,!25)
      - for guidance on how to migrate an existing configuration please read https://mrossinek.gitlab.io/programming/cobibs-new-configuration/
  - (DEV): `cobib.parser.Entry` has been moved to `cobib.database.Entry`
  - the `cobib.parsers` module has been extracted (prep for #49, !28)
  - the filenames of the associated files are preserved when exporting to a Zip file
  - when trying to add an entry with an existing label, the database is not written to and a warning is raised early
  - month conversion and special character escaping are only done upon saving entries to the database
  - the path to the default logfile can now be configured via `config.logging.logfile` and defaults to `~/.cache/cobib/cobib.log`


  - the `INI`-style configuration is deprecated
      - new configuration options will not be added to this style
      - only bugs which fully break usability will be fixed with regards to this configuration style
      - legacy-support will be fully removed on 1.1.2022


  - the ZSH helper utilities now respect the `-c`, `-l`, and `-v` command line options
  - the `RedoCommand` should only revert a previously `UndoCommand` operation (#65)
  - the `SearchCommand` got some contexts improvements and correctly splits grep results
  - unwrapping does not crash the TUI if the cursor was multiple lines below the new buffer height
  - line continuation guides are not swallowed by current line highlighting
  - ensure the TUI's top line does not become negative
  - the TUI's handler for resizing events
  - `JSONDecodeError`s thrown by the `ISBNParser` are caught and handled gracefully


  - the functions `read_database()` and `write_database()` are no longer available (!28)




  Pypi: https://pypi.org/project/cobib/2.6.1/

  Note: [2.6.1] was not released from the `master`-branch, which resulted in a non-linear development.


  - `init --git` will not initialize a repository unless git has configured both, `name` and `email`


  - TUI no longer crashes when aborting to quit (#64)




  Pypi: https://pypi.org/project/cobib/2.6.0/


  - Git integration (#44, !20):
      - will automatically track any changes done to the database file with git
      - must be enabled by setting the `DATABASE/git` option to `True` **and** running `cobib init --git`
      - Note, that you must have at least set a `name` and `email` in the git config!
  - Undo/Redo commands to operate on git history of the database (#59,!23)
      - for obvious reasons these commands require the Git integration (see above) to be enabled
  - the `Prompt` command inside of the TUI:
      - allows executing arbitrary CoBib CLI commands
      - the default key binding is `:`
  - the `Modify` command: (#60,!24)
      - allows bulk modification of multiple entries in a `<field>:<value>` format
      - for now, this will **always** overwrite the field with the new value!
      - an extension to appending values is planned for a later release
      - the set of entries to be modified can be specified just like with the `export` command through `list`-command filters or manual selection (by setting the `--selection` flag)


  - the viewport history is preserved correctly (#21,!22)
      - this allows performing a search while showing an entry and reverts back to the correct view after quitting the search
      - the changes mainly involved refactoring of the `cobib/tui` module
  - the **positional** argument of the `modify` and `search` has been renamed internally from `list_arg` to `filter`
      - this should not have any visible effect to an end-user but may be relevant to developers


  - gracefully handle multiple terminal sizing issues with regards to popups (#58)
  - catch messages on `stdout` during deletion from TUI
  - added missing help strings to the TUI help menu


  - The `--force` argument to the `init` command has now been removed (after being deprecated in v2.5.0).




  Pypi: https://pypi.org/project/cobib/2.5.0/


  - support for multiple associated files (#42,!19)
  - interactive menu when opening an entry with multiple associated files (!19)


  - The `--force` argument to the `init` command has been deprecated. I don't think there is any
    benefit to providing the user the option to nuke their database file from the CLI. Instead,
    they can simply edit the file manually.


  - always store years as strings to be compatible with bibtexparser
  - handle invalid arXiv or DOI IDs gracefully (#57)




  Pypi: https://pypi.org/project/cobib/2.4.1/


  - ISBN parser was missing the ENTRYTYPE and did not use strings for number fields
  - the ISBN parser can now handle empty entries (#53)
  - the TUI will not crash on stdout/stderr messages exceeding the window width
  - the TUI respects quoted strings in the prompt handler (#52)




  Pypi: https://pypi.org/project/cobib/2.4.0/


  - the `FORMAT/default_entry_type` option used for manual entry addition
  - a **manual** insertion mode available through `edit -a new_label` and `add -l new_label`
  - a ISBN-based parser for adding new entries (#45)
  - the TUI-based `select` command (and corresponding settings) (#8,!18)
  - the `--selection` argument for the `export` command (!18)


  - TUI color highlighting is now prioritized (!17)


  - support URLs in file field during `open` command (#47)
  - the TUI no longer crashes when encountering long prompt inputs (#48)
  - the `edit` command can handle labels which start with common substrings (#46)
  - support multiple ANSI colors on a single line (#50)




  Pypi: https://pypi.org/project/cobib/2.3.4/


  - another AUR package installation error




  Pypi: https://pypi.org/project/cobib/2.3.3/


  - AUR package installation error



  Pypi: https://pypi.org/project/cobib/2.3.2/


  - option to default to case-insensitive searching (`DATABASE/search_ignore_case`)


  - clearing the prompt, aborts the command execution


  - search command correctly handles missing arguments in TUI (#43)



  Pypi: https://pypi.org/project/cobib/2.3.1/


  - faulty Pypi package



  Pypi: https://pypi.org/project/cobib/2.3.0/


  - Logging functionality has been added. The verbosity level can be controlled via `-v` (INFO) and `-vv` (DEBUG).
    As soon as the TUI starts, all logging output is redirected to `/tmp/cobib.log`.
  - Command line argument `-l` or `--logfile` can be used to specify the output path of the log. This will overwrite the `/tmp/cobib.log` location.
  - the `TUI/scroll_offset` setting was added. It defaults to `3` and behaves similar to Vim's `scrolloff` setting.
  - Configuration validation has been added. This extends the logging functionality to support more runtime debug information.
  - popup window support: stdout and stderr messages are presented in a popup similarly to the help window


  - `-v` command line argument now refers to `--verbose` rather than `--version`
  - Performance of the `add` command has been improved by not refreshing the database when outside of the TUI.


  - bug when resizing causes the window width to become greater than the buffer width (#39)
  - do not escape special characters in labels (#40)
  - avoid special character encoding in file paths



  Pypi: https://pypi.org/project/cobib/2.2.2/


  - current line highlight if viewport is wider than buffer was not correctly reset
  - the `ignore_non_standard_types` setting had no effect



  Pypi: https://pypi.org/project/cobib/2.2.1/


  - when wrapping the TUI lines, indent until after the label column (#26)
  - renamed `default.ini` to `example.ini` in the documentation folder


  - current line highlight after viewport width was not correctly reset
  - correctly convert boolean configuration options (#34)
  - fix crash of TUI in wrap command when viewport is empty (#37)
  - default configuration settings are managed centrally and consistently (#35)




  Pypi: https://pypi.org/project/cobib/2.2.0/


  - allow configuring the program used to `open` associated files
  - prompt user before actually quitting CoBib (#33)
  - implements the Search command (#7, !12)


  - the default value of the `open` command was not set correctly




  Pypi: https://pypi.org/project/cobib/2.1.0/


  - added half- and full-page scrolling (#22)


  - importing from `bibtex` data defaults to **not** ignored non-standard entry types (#28)
  - suppress LaTex encoding warnings except when adding entries (#29)
  - `Search` and `Select` print warnings to the prompt while not implemented


  - `init` command ensures directory of database file exists
  - remove window artifacts after `help` menu is closed (#20)
  - configuration file detection was missing a user home expansion (#31)



  Pypi: https://pypi.org/project/cobib/2.0.0/


  - respect sort order reversing and filter `XOR`ing from the TUI (#18)
  - `edit` command on Mac OS (#19)


  - made `init` command safe against database overwriting
  - TUI: list entries in reverse order by default (config: TUI/reverse_order)




  Pypi: https://pypi.org/project/cobib/2.0.0b4/


  - reset viewport position when updating buffer




  Pypi: https://pypi.org/project/cobib/2.0.0b3/


  - properly assert valid current line number




  Pypi: https://pypi.org/project/cobib/2.0.0b2/


  - fixed TUI startup




  **Warning**: do NOT use! The TUI is broken in this release!

  Pypi: https://pypi.org/project/cobib/2.0.0b1/


  - TUI does not crash when opening an entry with no associated file
  - correctly reset current line positions after filtering and editing




  Pypi: https://pypi.org/project/cobib/2.0.0b0/


  - _internal_: refactored the config into a class
  - centralized the database handling to improve performance (#12,!9)


  - the `Show` command does not break after scrolling the viewport (#13)




  Pypi: https://pypi.org/project/cobib/2.0.0a2/


  - user configuration options for:
      - TUI colors
      - TUI key bindings
      - TUI default list arguments
  - help window highlighting


  - sorting and filtering commands remain persistent when updating the list view




  Pypi: https://pypi.org/project/cobib/2.0.0a1/


  - Added a basic curses-based TUI (#5,!7)


  - _internal_: refactored commands into separate module




  Pypi: https://pypi.org/project/cobib/1.1.0/


  - add `FORMAT.month` configuration option to configure the default type for
      month fields (defaults to `int`) (#3,!4)
  - escape special LaTeX characters (#2,!5)


  - `list` no longer breaks with a `KeyError` when a queried field does not exist
      in any bibliography entry (!2)
  - `--label` can now correctly overwrite the ID (#4,!3)


  - `set_config()` and global `CONFIG` exported to separate module




  Pypi: https://pypi.org/project/cobib/1.0.2/

  Note: this removal is not seen as a MINOR version bump because this is
        essentially a long out-standing bug fix


  - doi extraction from pdf files (476efc4f)
    - also removes the ability to add entries directly via pdf files




  Pypi: https://pypi.org/project/cobib/1.0.1/


  - metadata for pypi




  First MAJOR release. Also available via Pypi: https://pypi.org/project/cobib/1.0.0/
  The project was renamed from `CReMa` to `CoBib`


  - allow sorting the list output (2a5a94f1)
  - crude and slow (!!!) zsh completion (9f28f441)
  - support Darwin's `open` command


  - suppress list output when exporting
  - add used tags to columns when listing
  - sort YAML database entries by keys (d2af42d2)


  - fixed arxiv parser (7ce3726f)




  Note: this release was not marked MAJOR because this is still a WIP and early
        alpha release.


  - complete rewrite to use a plain-text `yaml` database instead of `sqlite3` !1


  - `sqlite3` database





  - initial version with a basic `sqlite3`-based database


  [Unreleased]: https://gitlab.com/cobib/cobib/-/compare/v5.2.1...master
  [5.2.1]: https://gitlab.com/cobib/cobib/-/tags/v5.2.1
  [5.2.0]: https://gitlab.com/cobib/cobib/-/tags/v5.2.0
  [5.1.3]: https://gitlab.com/cobib/cobib/-/tags/v5.1.3
  [5.1.2]: https://gitlab.com/cobib/cobib/-/tags/v5.1.2
  [5.1.1]: https://gitlab.com/cobib/cobib/-/tags/v5.1.1
  [5.1.0]: https://gitlab.com/cobib/cobib/-/tags/v5.1.0
  [5.0.1]: https://gitlab.com/cobib/cobib/-/tags/v5.0.1
  [5.0.0]: https://gitlab.com/cobib/cobib/-/tags/v5.0.0
  [4.5.0]: https://gitlab.com/cobib/cobib/-/tags/v4.5.0
  [4.4.0]: https://gitlab.com/cobib/cobib/-/tags/v4.4.0
  [4.3.1]: https://gitlab.com/cobib/cobib/-/tags/v4.3.1
  [4.3.0]: https://gitlab.com/cobib/cobib/-/tags/v4.3.0
  [4.2.0]: https://gitlab.com/cobib/cobib/-/tags/v4.2.0
  [4.1.0]: https://gitlab.com/cobib/cobib/-/tags/v4.1.0
  [4.0.0]: https://gitlab.com/cobib/cobib/-/tags/v4.0.0
  [3.5.5]: https://gitlab.com/cobib/cobib/-/tags/v3.5.5
  [3.5.4]: https://gitlab.com/cobib/cobib/-/tags/v3.5.4
  [3.5.3]: https://gitlab.com/cobib/cobib/-/tags/v3.5.3
  [3.5.2]: https://gitlab.com/cobib/cobib/-/tags/v3.5.2
  [3.5.1]: https://gitlab.com/cobib/cobib/-/tags/v3.5.1
  [3.5.0]: https://gitlab.com/cobib/cobib/-/tags/v3.5.0
  [3.4.0]: https://gitlab.com/cobib/cobib/-/tags/v3.4.0
  [3.3.2]: https://gitlab.com/cobib/cobib/-/tags/v3.3.2
  [3.3.1]: https://gitlab.com/cobib/cobib/-/tags/v3.3.1
  [3.3.0]: https://gitlab.com/cobib/cobib/-/tags/v3.3.0
  [3.2.1]: https://gitlab.com/cobib/cobib/-/tags/v3.2.1
  [3.2.0]: https://gitlab.com/cobib/cobib/-/tags/v3.2.0
  [3.1.1]: https://gitlab.com/cobib/cobib/-/tags/v3.1.1
  [3.1.0]: https://gitlab.com/cobib/cobib/-/tags/v3.1.0
  [3.0.0]: https://gitlab.com/cobib/cobib/-/tags/v3.0.0
  [2.6.1]: https://gitlab.com/cobib/cobib/-/tags/v2.6.1
  [2.6.0]: https://gitlab.com/cobib/cobib/-/tags/v2.6.0
  [2.5.0]: https://gitlab.com/cobib/cobib/-/tags/v2.5.0
  [2.4.1]: https://gitlab.com/cobib/cobib/-/tags/v2.4.1
  [2.4.0]: https://gitlab.com/cobib/cobib/-/tags/v2.4.0
  [2.3.4]: https://gitlab.com/cobib/cobib/-/tags/v2.3.4
  [2.3.3]: https://gitlab.com/cobib/cobib/-/tags/v2.3.3
  [2.3.2]: https://gitlab.com/cobib/cobib/-/tags/v2.3.2
  [2.3.1]: https://gitlab.com/cobib/cobib/-/tags/v2.3.1
  [2.3.0]: https://gitlab.com/cobib/cobib/-/tags/v2.3.0
  [2.2.2]: https://gitlab.com/cobib/cobib/-/tags/v2.2.2
  [2.2.1]: https://gitlab.com/cobib/cobib/-/tags/v2.2.1
  [2.2.0]: https://gitlab.com/cobib/cobib/-/tags/v2.2.0
  [2.1.0]: https://gitlab.com/cobib/cobib/-/tags/v2.1.0
  [2.0.0]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0
  [2.0.0b4]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b4
  [2.0.0b3]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b3
  [2.0.0b2]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b2
  [2.0.0b1]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b1
  [2.0.0b0]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b0
  [2.0.0a2]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0a2
  [2.0.0a1]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0a1
  [1.1.0]: https://gitlab.com/cobib/cobib/-/tags/v1.1.0
  [1.0.2]: https://gitlab.com/cobib/cobib/-/tags/v1.0.2
  [1.0.1]: https://gitlab.com/cobib/cobib/-/tags/v1.0.1
  [1.0.0]: https://gitlab.com/cobib/cobib/-/tags/v1.0.0
  [0.2]: https://gitlab.com/cobib/cobib/-/tags/v0.2
  [0.1]: https://gitlab.com/cobib/cobib/-/tags/v0.1


pkgId: beb18d5d5bcd236f4ab04a1461927167e1f1609e857b5a8594a22c13ee70cbb0
name: python-cobib
arch: src
version: 5.2.2
epoch: 0
release: 1
summary: Console Bibliography
url: https://gitlab.com/cobib/cobib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobib-5.2.2-1.src.rpm
checksum_type: sha256
description:
  [![coBib](https://gitlab.com/cobib/cobib/-/raw/master/logo/cobib_logo.svg)](https://cobib.gitlab.io/cobib/cobib.html)



  [![pipeline](https://gitlab.com/cobib/cobib/badges/master/pipeline.svg)](https://gitlab.com/cobib/cobib/-/pipelines)
  [![coverage](https://gitlab.com/cobib/cobib/badges/master/coverage.svg)](https://gitlab.com/cobib/cobib/-/graphs/master/charts)
  [![PyPI](https://img.shields.io/pypi/v/cobib)](https://pypi.org/project/cobib/)

  coBib is a simple, command-line based bibliography management tool.
  It is the result of the need for an easy-to-use alternative to full-blown reference managers like Mendeley or Zotero.
  As such it follows some basic design goals:

  * **plain-text database**: which means you get full access and control over the database.
  * **git-integration**: as a benefit of the above, you can keep track of your database through version control.
  * **centralized database, location-independent library**: this means, that coBib *only* manages the
    database file in a centralized fashion but allows you to spread the actual contents of your
    library across the entire file system (this is the major different to
    [papis](https://papis.readthedocs.io/en/latest/library_structure.html)).
  * **command-line and TUI support**: all features are available through the command-line as well as a
    [textual](https://textual.textualize.io/)-based TUI




  For all common purposes you can install coBib via `pip`:

  ```
  pip install cobib
  ```

  Note: Use `pip3` if you still have Python 2 installed.

  If you would also like to install the man-page, you need to download the source
  code and do the following:

  ```
  git clone https://gitlab.com/cobib/cobib
  cd cobib
  make install_extras
  ```



  coBib is packaged in the AUR.
  * [cobib](https://aur.archlinux.org/packages/cobib/)
  * [cobib-git](https://aur.archlinux.org/packages/cobib-git/)



  coBib _might_ work on Windows as is, but it is not being tested so no guarantees are given.
  If you are using Windows 10 or later and are running into issues, you should be able to install and
  use coBib's full functionality within the Linux subsystem.




  To get started, you must initialize the database:

  ```
  cobib init
  ```

  If you would like to enable the git-integration, you should run:

  ```
  cobib init --git
  ```

  *and* enable `config.database.git` (see also [configuration](#configuration)).

  Be sure to check out my [Quickstart blog post](https://mrossinek.gitlab.io/programming/introducing-cobib/)
  for a more guided introduction compared to the following section!



  coBib provides an `import` command through which you can easily import your library
  from another bibliography manager. For more details check out:

  ```
  cobib import --help
  ```

  So far, coBib knows how to import your library from Zotero by simply running:

  ```
  cobib import --zotero
  ```

  Check out the following command, the man page or the online documentation for more details:

  ```
  cobib import --zotero -- --help
  ```





  You can now add new entries to your database (see also `cobib.commands.add`[^1]):

  ```
  cobib add --bibtex some_biblatex_file.bib
  cobib add --arxiv <some arXiv ID>
  cobib add --doi <some DOI>
  cobib add --isbn <some ISBN>
  ```

  **Note**: when adding data from a `.bib` file, make sure that it is in the Bib**La**Tex format!



  You can view the contents of your database with (see also `cobib.commands.list_`):

  ```
  cobib list
  ```

  You can show a specific entry with (see also `cobib.commands.show`):

  ```
  cobib show <some entry label>
  ```

  You can open an associated file of an entry with (see also `cobib.commands.open`):

  ```
  cobib open <some entry label>
  ```

  You can even search through your database with (see also `cobib.commands.search`):

  ```
  cobib search "some text"
  ```



  You can delete an entry with (see also `cobib.commands.delete`):

  ```
  cobib delete <some entry label>
  ```

  You can edit an entry manually with (see also `cobib.commands.edit`):

  ```
  cobib edit <some entry label>
  ```

  You can also apply simple modifications to multiple entries at once with (see also
  `cobib.commands.modify`):

  ```
  cobib modify tags:private -- <some entry label> <another entry label> ...
  ```



  You can export your database with (see also `cobib.commands.export`):

  ```
  cobib export --bibtex my_bibliography.bib
  cobib export --zip my_library.zip
  ```



  If you have enabled the git-integration, you can undo and re-apply changes to your database with
  (see also `cobib.commands.undo` and `cobib.commands.redo`):

  ```
  cobib undo
  cobib redo
  ```



  Each subcommand provides additional help via:

  ```
  cobib <subcommand> --help
  ```

  and you can find extensive information in the online documentation (linked above) and the man-page:

  ```
  man cobib
  ```



  Finally, you can also use coBib's TUI for a more interactive experience (see also `cobib.ui.tui`),
  by simply typing
  ```
  cobib
  ```

  Here is an example screenshot of the TUI when listing the entries in your database:

  ![coBib TUI List](https://gitlab.com/cobib/cobib/-/raw/master/html/cobib_tui_list.svg)

  And here is an example screenshot for listing search results:

  ![coBib TUI Search](https://gitlab.com/cobib/cobib/-/raw/master/html/cobib_tui_search.svg)




  You can overwrite the default configuration by placing a `config.py` file in `~/.config/cobib/`.
  The easiest way to get started with this file is by copying [`example.py`](https://gitlab.com/cobib/cobib/-/blob/master/src/cobib/config/example.py)
  or by using:

  ```
  cobib _example_config > ~/.config/cobib/config.py
  ```

  You can then modify it to your liking.

  You may also specify a different config file at runtime by using the `-c` or `--config` command line argument or by specifying a custom path in the `COBIB_CONFIG` environment variable.
  You can also disable loading of _any_ configuration file be setting this environment variable to one of the following values: `"", 0, "f", "false", "nil", "none"`.

  Finally, be sure to take a look at the man page (`man cobib`) and/or the online documentation for more information.




  coBib supports the implementation of plugins!
  You can find an example plugin in [this folder](./plugin) or read the docs of
  `cobib_dummy` (when viewing the hosted documentation online).




  coBib's documentation is hosted [here](https://cobib.gitlab.io/cobib/cobib.html).

  If you would like to generate a local version during development, you need to clone the source code, and install [`pdoc`](https://github.com/mitmproxy/pdoc) in order to generate it:

  ```
  git clone https://gitlab.com/cobib/cobib.git
  cd cobib
  pip install pdoc
  pdoc -d google -e cobib=https://gitlab.com/cobib/cobib/-/blob/master/src/cobib/ -t html -o docs src/cobib tests
  ```

  You can then browse the documentation from `docs/cobib.html`.




  I have started this project when I was looking into alternatives to popular reference managers such as Mendeley,
  which has more features than I use on a regular basis and does not allow me to work from the command line which is where I spent most of the time that I spent on the computer.

  Hence, I have decided to make it my own task of implementing a simple, yet fast, reference manager.
  coBib is written in Python and uses a YAML file to store its bibliography in a plain text format.



  You can find the detailed changes throughout coBib's history in [the Changelog](https://gitlab.com/cobib/cobib/-/blob/master/CHANGELOG.md).




  coBib is licensed under the [MIT License](https://gitlab.com/cobib/cobib/-/blob/master/LICENSE.txt).

  [^1]: References like this one get interpreted by the documentation generator. If you are reading this as the README page, you may find the [online documentation](https://cobib.gitlab.io/cobib/cobib.html) more enjoyable.

  [//]: # ( vim: set ft=markdown: )


  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).






  Pypi: https://pypi.org/project/cobib/5.2.2/



  - The `config.theme.dark` and `config.theme.design` settings have been replaced
    by the new `config.theme.theme` setting, which can be either the name of one
    of textual's builtin themes, or a custom `textual.theme.Theme` instance
    (#147,!279). Due to how recent these settings have been introduced (as part of
    5.2.0), I am opting for a quick removal in this bugfix release rather than a
    proper version bump (in the sense that they have likely not been adopted, yet)
    and the severness of the bug that this is causing outweighs the needs here.



  - compatibility with `textual>=0.86`




  Pypi: https://pypi.org/project/cobib/5.2.1/



  - compatibility with `textual>=0.80`




  Pypi: https://pypi.org/project/cobib/5.2.0/



  With the addition of the new `note` command, the database entry fields called
  `"note"` have obtained a special meaning. Use the `lint` command to check
  whether your database is affected by this. If it is, you should rename those
  fields.


  - new configuration settings to customize the appearance of coBib (!222):
    - `cobib.config.theme.dark`: to specify whether a dark or light theme is used
    - `cobib.config.theme.design`: to customize the colors themselves
    - the following settings to customize the appearance of `rich.Syntax` displays:
      - `cobib.config.theme.syntax.theme`
      - `cobib.config.theme.syntax.background_color`
      - `cobib.config.theme.syntax.line_numbers`
  - the `note` command (#139,!206).
    Please refer to its online documentation or the man-page for more details on
    how to use it.
    This new command comes with:
    - the `cobib.config.commands.note.default_filetype` setting
    - the `PreNoteCommand` and `PostNoteCommand` event hooks
  - (DEV) the `add_files` argument to the `BaseCommand.git` function
  - Python 3.13 is now officially tested and supported
  - new configuration settings for the search command (#146,!269)
    - For dealing with skipping/including associated files during searches:
      - `cobib.config.commands.search.skip_files` sets the default
      - `--skip-files` overwrites this at runtime (this is not actually new)
      - `--include-files` overwrites this at runtime (the opposite)
    - For dealing with skipping/including associated notes during searches:
      - `cobib.config.commands.search.skip_notes` sets the default
      - `--skip-notes` overwrites this at runtime (this is not actually new)
      - `--include-notes` overwrites this at runtime (the opposite)


  - the keybinding to recursively toggle all folds in the TUI's search result view
    was changed from `ENTER` to `BACKSPACE` (!218)
  - (DEV) `cobib.ui.components.entry_points` was moved to `cobib.utils.entry_points`
  - replaced the custom help screen with textual's new builtin help panel (!240)


  - the behavior of the `Home` and `End` keybindings in the TUI's list view (!217)
  - gracefully handles Zotero imported entries without a `journal` field (#145)




  Pypi: https://pypi.org/project/cobib/5.1.3/


  - the behavior of the `Home` and `End` keybindings in the TUI's list view (!217)




  Pypi: https://pypi.org/project/cobib/5.1.2/


  - support database locations in nested folders of a git repository (!204)




  Pypi: https://pypi.org/project/cobib/5.1.1/



  - when printing the changelog, do not remove list indents




  Pypi: https://pypi.org/project/cobib/5.1.0/



  Check out my blog post to learn more about the features of this new release:
  https://mrossinek.gitlab.io/programming/cobib-becomes-fuzzy/


  - approximate (or fuzzy) filter matching and search functionality (#107,#130,!177)
    - the `list` and `search` commands now support the following features to
      perform approximate filter matching and searching, respectively:
      - LaTeX sequences can be decoded to Unicode characters:
        - using `--decode-latex` from the command-line
        - setting `config.commands.list_.decode_latex = True`
        - setting `config.commands.search.decode_latex = True`
      - Unicode characters can be converted to a close ASCII equivalent:
        - using `--decode-unicode` from the command-line
        - setting `config.commands.list_.decode_unicode = True`
        - setting `config.commands.search.decode_unicode = True`
      - a number of fuzzy errors can be set (this requires the optional dependency
        [`regex`](https://pypi.org/project/regex/) to be installed):
        - using `--fuzziness <int>` from the command-line
        - setting `config.commands.list_.fuzzines` to some integer
        - setting `config.commands.search.fuzzines` to some integer
  - (DEV) the following method arguments have been converted to be accepted only
    as keyword arguments:
    - in `cobib.database.Entry.matches`: `ignore_case`
    - in `cobib.database.Entry.search`: `context`, `ignore_case`, and `skip_files`
  - (DEV) the return-type of `cobib.database.Entry.search` has been changed




  Pypi: https://pypi.org/project/cobib/5.0.1/


  - the ability to use an empty string as the separator in `config.database.format.label_suffix` (#138)




  Pypi: https://pypi.org/project/cobib/5.0.0/



  - the ability to add custom `commands`, `importers`, and `parsers` through entry points (#135, !139)
    - (DEV) a dummy plugin show-casing these extensions


  - the entire `shell_helper` module has been replaced as follows (!139):
    - the following deprecated helper methods were removed without replacement:
      - `_list_commands`
      - `_list_filters`
      - `_list_labels`
    - the following secondary commands have been refactored:
      - `_lint_database` is now `cobib.commands.lint.LintCommand`
      - `_unify_labels` is now `cobib.commands.unify_labels.UnifyLabelsCommand`
      - `_example_config` is now `cobib.config.command.ExampleConfigCommand`
  - the interactive disambiguation mechanism during the `add` command now handles
    multiple matching related entries (#121,!168)
    - this includes the ability to `cancel` the disambiguation and entry addition



  - the previously deprecated `console` attribute of all commands has been removed (!139)
  - the previously deprecated `prompt` attribute of all commands has been removed (!139)
  - the `cobib.ui.shell_helper` and `cobib.utils.shell_helper` modules have been removed (!139)
  - the previously deprecated `--update` argument of the `add` command (!168)
  - the previously deprecated `--skip-existing` argument of the `add` command (!168)
  - the previously deprecated `LabelSuffix.CAPTIAL` attribute (!168)
  - Python 3.8 is no longer supported (!173)




  Pypi: https://pypi.org/project/cobib/4.5.0/


  - the new `cobib.utils.context.get_active_app` method which returns any running
    textual App and replaces the need for the `cobib.utils.prompt.Prompt.console`
    and `cobib.utils.progress.Progress.console` (which have been removed) (!137)
  - `cobib.parsers.YAMLParser.parse` can now also parse strings directly (rather
    than always interpreting the argument as the path to a file) (!137)
  - the `review` command (#131,!137).
    Please refer to its online documentation or the man-page for more details on
    how to use it.
  - the `cobib.database.Entry.merge` method (!137)


  - log messages will now be displayed in the `LogPanel` of the TUI (which can be
    toggled with the `z` keybinding) (#132,!133)
  - the `cobib.ui.components.prompt` module has been refactored into `cobib.utils.prompt` (!133)


  - the `console` argument to all commands has been deprecated since it no longer
    has any effect (!133)
  - the `prompt` argument to all commands has been deprecated since it no longer
    has any effect (!133)
  - access to the following `shell_helper` commands will change in the next release:
    - `cobib _lint_database` will become `cobib lint`
    - `cobib _unify_labels` will become `cobib unify_labels`
    - `cobib _example_config` will become `cobib example_config`


  - loading a cached database will be bypassed during `_lint_database` (#133)
    - to support this the `bypass_cache` keyword-argument was added to the
      `Database.read` method


  - official Windows support label. It _might_ work but no guarantees are made (#136)




  Pypi: https://pypi.org/project/cobib/4.4.0/


  - a primitive caching mechanism to speed up the database loading. This feature
    is enabled by default and will store its cache at `~/.cache/cobib/databases/`.
    You can configure the location via `config.database.cache` or even disable
    caching entirely by changing this setting to `None`. (see also #129 and !108)
  - added the `-r/--remove` option to the `modify` command (#128)
    - this can achieve the opposite of `-a/--add` in the sense that it will try to
      remove the specified modification from a list or subtract a number from
      numeric values
    - other field types than lists or numbers are not supported by this option
  - added the `-l/--limit` option to the `list` command (#127)
    - exposed the `ListCommand.sort_entries` method in the public API
    - added the `ListCommand.execute_dull` method in the public API
  - the `search`, `export`, and `modify` commands now also support sorting and limiting options to be
    passed onto the `list` command (along with the already existing filtering options)
  - the `config.tui.tree_folding` setting which allows you to configure the
    default folding state of the tree nodes in the TUI's search result view
  - the `ENTER` binding in the TUI's search result view to recursively toggle all
    folds of the current node


  - when using the TUI you may now use the `:show <label>` command to jump to the
    specified label (#126,!116)
  - the `search` command now reports its progress live (!117)


  - unblocked the vertical scrollbar of the TUI's list view from the scroll offset




  Pypi: https://pypi.org/project/cobib/4.3.1/


  Note, that the introduction of the detailed author information parsing in v4.3.0
  resulted in possible breaking of a custom `config.database.format.label_default`
  setup. This bugfix release is meant to emphasize this breaking change and
  updates the documented example in the example configuration file. For the sake
  of verbosity, here is the change applied to the example:

  - old: `"{unidecode(author.split(' and ')[0].split()[-1])}{year}"`
  - new: `"{unidecode(author[0].last)}{year}"`




  Pypi: https://pypi.org/project/cobib/4.3.0/




  coBib now has the ability to store more detailed author information (see #92 and
  !88). This means, that the `author` field of an entry is analyzed in more detail
  and coBib will separate out the first and last names as well as name pre- and
  suffixes. The new setting `config.database.format.author_format` determines,
  whether this detailed information is kept directly in the database (the
  `AuthorFormat.YAML` setting; the **new default**) or is only constructed at
  runtime and the author field is still simply saved in BibLaTeX form
  (`AuthorFormat.BIBLATEX`).

  Note, that the `YAML` format also implies, that Unicode characters are allowed
  and will *not* be encoded in LaTeX form. This has an effect on how you may need
  to format your searches. See also #130 for some more insights on this.

  If you have company names or any author name which you want to have treated
  verbatim, you can simply wrap it in curly braces (e.g. `{My Company}`).
  Refer to the online documentation of `cobib.database.Author` and the above
  setting for more details.


  coBib now has a [Wiki](https://gitlab.com/cobib/cobib/-/wikis/home) where we can
  gather useful configuration resources and other details which may not make it
  into the full documentation.

  For example, if you are interested in the tracking more metadata of your
  database (as suggested in #123), be sure to check out
  [this wiki page](https://gitlab.com/cobib/cobib/-/wikis/Useful-Event-Hooks)!


  - the `-f` short-hand alias for the `--field` argument of the `open` command
  - the `opened_entries` attribute of the `OpenCommand` (which is accessible during the `PostOpenCommand` hook)
  - the new `git` command to simplify running git operations on the database (#124)
  - new bindings for `Home`, `End`, `PageUp`, and `PageDown` in the TUI
  - (DEV) added a new `DEPRECATED` logging level which has value 45
  - Python 3.12 is now officially tested and supported
  - the `config.commands.show.encode_latex` setting
  - the `encode_latex` attribute to the `BibtexParser`
  - the `config.database.format.verbatim_fields` setting
  - the `config.database.format.author_format` setting. The new default behavior
    is to store detailed author information in YAML form.
  - the `encode_latex` keyword-argument to the `Entry.stringify` method
  - the `Entry.formatted` method. This replaces the `Entry.escape_special_chars` method.


  - an error will be logged when a file is not found during the `open` command
  - the following commands are now treated specially when run via the `:` prompt of the TUI:
    - `init`: will log an error
    - `git`: will log an error
    - `show`: will log a warning


  - The `LabelSuffix.CAPTIAL` value because it was misspelled. Please use `LabelSuffix.CAPITAL` instead.


  - non-asynchronous commands triggered via the `:` prompt of the TUI will no longer break it (#125)
  - ensure UTF-8 encoding is used for downloaded data (this fixes many odd encounters w.r.t. special characters)
  - the spelling of the `LabelSuffix.CAPITAL` value (it used to be spelled `LabelSuffix.CAPTIAL`)


  - the `Entry.escape_special_chars` method. Use `Entry.formatted` instead.




  Pypi: https://pypi.org/project/cobib/4.2.0/


  - added the `config.tui.scroll_offset` setting
  - added the `--field` command line option to the `open` command
  - (DEV) added a new `HINT` logging level which has value 35 and thus allows to
    provide information to the user with a higher priority than `WARNING`
  - added the new `config.tui.preset_filters` (#114)
    - preset filters can be selected from the TUI via the `p` key binding
    - the first 9 filters can be selected directly by pressing the respective number
    - pressing `0` resets any applied filter
  - implemented special tags (#63,!83)
    - adds new builtin tags which will trigger special highlights of entries: `new`, `high`, `medium`, `low`
    - adds the new `config.theme` settings section for configuring these settings
    - you can also add more special tags via `config.theme.tags.user_tags`
  - added the `--skip-files` command line option to the `search` command


  - unicode symbols in entry labels will now be replaced with ascii ones (#119,#120)
    - this is configured via the `config.database.format.default_label` setting, so if you are using a
      custom value for this, be sure to update your config to make use of this feature
  - some user-visible logging messages around label disambiguation have been added (see also #121)
  - a warning has been added when the YAML parser encounters identical labels (which normally should
    not occur in the database but if it does, coBib does not really know how to resolve this)
  - DOI redirect links are now followed recursively (up to 3 times), improving PDF
    download link detection in the process (#97)


  - the `config.commands.search.highlights` section is deprecated in favor of `config.theme.search`


  - retain scroll position in the TUI's list view




  Pypi: https://pypi.org/project/cobib/4.1.0/


  - added the following settings which specify whether or not to preserve
    associated files during the respective commands being run:
    - `config.commands.delete.preserve_files`
    - `config.commands.edit.preserve_files`
    - `config.commands.modify.preserve_files`
  - added a confirmation prompt before deleting an entry (#110)
    - this prompt can be disabled by setting `config.commands.delete.confirm` to `False`
  - added the `--no-ignore-case` (`-I` for short) command line options to the
    `list` and `search` command (#116)
  - added the `--no-preserve-files` command line options to the `delete`, `edit`
    and `modify` command (#116)
  - added the `config.commands.search.context` setting which configures the
    default number of context lines to be provided for search query matches
  - added more options to configure the automatic download behavior:
    - the new `config.commands.add.skip_download` setting
    - the new `--force-download` option of the `add` command
    - the new `config.commands.import_.skip_download` setting
    - the new `--force-download` option of the `import` command
  - the user is asked for confirmation when quitting the TUI (!71)


  - refactored the TUI by leveraging textual's `Screen` concept (#111,!71)
    - this means the TUI will look slightly different but no real functional change has occurred
    - the view of an `Entry` can now be scrolled when the output exceeds the available space
  - switched from the `BeautifulSoup` HTML parser to `lxml`
    - this is supposed to give more accurate results but adds an extra dependency


  - The following shell helpers are no longer used with the zsh completion being
    removed. Thus, these methods will be removed in the future:
    - `cobib _list_commands`
    - `cobib _list_filters`
    - `cobib _list_labels`
    - If you see warnings because of this while you are using the CLI, you
      probably still have the (now removed) zsh completion script installed. You
      should remove the `_cobib` file which will be located in one of the
      directories listed in your `$FPATH` environment variable.


  - the proper pre-population of the TUI prompt during the sorting action (#117)
  - preserves the value of `config.commands.list_.default_columns` and
    properly removes a field if it is no longer sorted by in the TUI (#117)
  - properly updates the list of entries in the TUI after changing the database contents;
    for example via `add` (#113) or `delete` (#113) or `edit` (#118)
  - an issue where file-accessing operations performed on a newly added entry within
    the same TUI session would fail because the path would not be iterated correctly
  - the live updating of the download progress bar inside the TUI (#112)


  - the crude and very slow zsh completion script




  Pypi: https://pypi.org/project/cobib/4.0.0/


  - Configuration settings can no longer be set by item access and instead must
    use attribute syntax. For example you need to change:
    ```python
    config["database"]["git"] = True
    ```
    to
    ```python
    config.database.git = True
    ```
    - the `config.commands.list` section had to be renamed to `config.commands.list_`
    - the `config.tui` section has been entirely removed
  - The `cobib.commands.list` module was moved to `cobib.commands.list_`.
  - The function signature of all command- and importer-related events has changed!
    For more details please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html).


  - Python 3.11 is now officially tested and supported
  - Full rewrite of all commands to use `rich` for a nicer CLI (#78,!51)
  - Full rewrite of the TUI based on `textual` (#78,!51)
  - the `--disambiguation` argument of the `add` command (#99,!58)
  - the `--ignore-case` argument of the `list` command (#105)
    - this also comes with the new `config.commands.list_.ignore_case` setting
  - the `search` command now accepts multiple query strings at once which will be
    searched over independently (#106)


  - the new default value of `config.parsers.yaml.use_c_lib_yaml` is now `True` as announced in version [3.4.0]
  - refactored the entire config as a dataclass (!63)
    - this implies that settings can only be set via attributes
    - but as a benefit the maintainability and documentation have improved significantly
  - The function signature of all command-related events has changed! Please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)
    for more details. (!63)
  - The function signature of all importer-related events has changed! Please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)
    for more details. (!66)
  - the API of the `cobib.commands` and `cobib.importers` module has been improved (!64)
    - this should not have any end-user facing effects
  - the `cobib.commands.list` module was moved to `cobib.commands.list_`


  - the `--update` argument of the `add` command is deprecated in favor of `--disambiguation update`
  - the `--skip-existing` argument of the `add` command is deprecated in favor of `--disambiguation keep`


  - the detection whether an entry already exists broke when label disambiguation was added in [3.3.0]
    and is now fixed by means of an interactive prompt during the `add` command


  - the warning triggered upon setting `config.database.format.month` which got removed in [3.1.0]
  - Python 3.7 is no longer supported




  Pypi: https://pypi.org/project/cobib/3.5.5/


  - opening of non-list type fields (#100)




  Pypi: https://pypi.org/project/cobib/3.5.4/


  - missing files encountered during searching will log warnings gracefully instead of harshly
  - handle newline characters in the TUI (#98)




  Pypi: https://pypi.org/project/cobib/3.5.3/


  - incorrect author concatenation in ISBN Parser
  - using the disambiguated label for the names of downloaded files (#96)




  Pypi: https://pypi.org/project/cobib/3.5.2/


  - run TUI on BSD platforms (!52)




  Pypi: https://pypi.org/project/cobib/3.5.1/


  - safely check cache existence before attempting to write (#94)




  Pypi: https://pypi.org/project/cobib/3.5.0/


  The plan is to switch to [rich][rich] and [textual][textual] instead of the current curses TUI.
  This will open up some great possibilities for a much more modern UI.

  However, this change will require some *major* refactoring including breaking changes of the API
  and some of the user configuration options. It will also be a rather drastic change in style.
  Thus, I will attempt to support v3.5 with bugfix releases until 1.1.2023

  It will likely take a few months until v4.0 gets released but I am starting development on it now.
  You can follow the progress here: <https://gitlab.com/cobib/cobib/-/issues/78>

  [rich]: https://github.com/Textualize/rich
  [textual]: https://github.com/Textualize/textual


  - the configuration loading can be disabled via the environment variable `COBIB_CONFIG`
      - values which disable the loading entirely are: `"", 0, f, false, nil, none`
      - you can also specify a custom path to a configuration file in this variable


  - the `INI`-style configuration got fully removed (as deprecated in [3.0.0] - 2021-04-10)




  Pypi: https://pypi.org/project/cobib/3.4.0/

  - coBib now requires the `requests-oauthlib` package
      - technically this is an optional dependency for now, but it will likely become a requirement soon


  - the new `config.parsers.yaml.use_c_lib_yaml` setting which significantly improves loading performance
      - this setting will change its default value to `True` in version 4.0.0
  * the `Import` command (#86,!49):
      - can be used to import libraries from other bibliography managers (see next bullet)
      - see `cobib import --help` for more information
  - the `cobib.importers` module:
      - provides importer classes for various other bibliography managers
      - these get registered at runtime under the `cobib import` command
      - this release provides the `--zotero` importer
      - see `cobib import --zotero -- --help` for more information
  - the `config.logging.cache` option, specifying the location of a simple json cache
  - the `config.commands.open.fields` option, specifying the names of the data fields which are checked for openable URLs (#89)


  - the `PreFileDownload` event now takes an additional argument: `headers: Optional[Dict[str, str]]`


  - downloaded file names will not duplicate the `.pdf` suffix




  Pypi: https://pypi.org/project/cobib/3.3.2/


  - re-enable the terminal keypad during resize event
      - this ensures proper arrow-key behavior after returning from an external editor
  - clear screen after closing TUI to remove all screen artifacts


  - remove warning when using the DOI parser because the upstream issue related to #91 got fixed




  Pypi: https://pypi.org/project/cobib/3.3.1/


  - erroneous label disambiguation of Entry labels which already conform with `config.database.format.default_label_format` (#87,!47)
  - do not add empty file list when unifying database


  - log warning when using the DOI parser because of (#91)




  Pypi: https://pypi.org/project/cobib/3.3.0/


  - print Changelog since the last run version (cached in `config.logging.version`) (#82)
  - the `AddCommand` now has a new `--update` option (#79,!41)
  - the `_lint_database` utility now takes the `--format` argument, which automatically resolves all lint messages (#81,!42)
  - the new `URLParser` (available via `cobib add --url <URL>` (#84,!44)
      - it attempts importing from a plain URL
      - simultaneously the arXiv, DOI, and ISBN parsers now also support URL containing a matching identifier directly
  - the `--dry` argument of the `ModifyCommand` to prevent errors during large bulk modifications
  * the `config.database.format.label_default` and `config.database.format.label_suffix` options (#85,!45)
      - labels will automatically be formatted according to the default option
      - if labels conflict with existing ones, the suffix option will be used for disambiguation
      - the `AddCommand` has a new `--skip-existing` option which disables automatic label disambiguation
      - use `cobib _unify_labels --apply` to unify all labels in your database
  - subscribable events (#71,!46)
      - allows registering of hooks to be executed in certain situation
      - more information is provided at the [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)


  - when an unknown variable is encountered in the modification of the `modify` command it falls back to an empty string rather than the name of the attempted variable


  - the `-s` option of the `AddCommand` is no longer available. You need to write out `--skip-download`
  - the `ID` filter argument on the `list` command (deprecated in v3.2.0 in favor of the `label` filter)




  Pypi: https://pypi.org/project/cobib/3.2.1/


  - when adding multiple entries at once, continue adding after encountering a single duplicate (#83)




  Pypi: https://pypi.org/project/cobib/3.2.0/


  - basic auto-downloading of PDF files for arXiv IDs and configured DOIs (#25,!35,!39):
      - the default download location can be configured via `config.utils.file_downloader.default_location`
      - on a per addition basis, this default can be overwritten via the `--path` keyword option of the `AddCommand`
      - if a file already exists in this location of the file system, the download will be skipped
      - download for DOI entries must configure URL patterns in `config.utils.file_downloader.url_map`
      - on a per addition basis, the entire automatic download can be skipped with `--skip-download`
  - automatic journal abbreviations (#62,!36):
      - users can configure a list of journal abbreviations via `config.utils.journal_abbreviations`
      - if present, coBib will store the journal in its elongated form
      - a user can then automatically convert to abbreviated forms during exporting (see the new `--abbreviate` and `--dotless` arguments)
  - Tentative Windows support by disabling the TUI
  - a `--preserve-files` argument was added to the following commands. Unless it is given, these will delete/rename associated files of affected entries:
      - `DeleteCommand`
      - `EditCommand`
      - `ModifyCommand`


  - the `modifications` of a `ModifyCommand` get interpreted as f-strings (#77,!37):
      - available variables are the entry's label and data fields
  - any `ListCommand` filter gets interpreted as a regex pattern (#76)


  - the `ID` filter argument was fully replaced by `label`, unifying the CLI API. Support will be dropped in v3.3.0


  - Removed (most) duplication of log messages




  Pypi: https://pypi.org/project/cobib/3.1.1/


  - Pypi package metadata




  Pypi: https://pypi.org/project/cobib/3.1.0/


  - the YAML format of the database has been extended to support the following: (#55)
      - numbers can be stored as integers
      - the `ID` field is no longer required and will be properly inferred from the label
      - the following fields can be stored as lists: `file`, `tags`, `url`
  - three new configuration options were added to complement the above list format options:
      - `config.database.stringify.list_separator.file`
      - `config.database.stringify.list_separator.tags`
      - `config.database.stringify.list_separator.url`
  - the `_lint_database` shell utility has been added which can be used to detect possible improvements for the database
  - the append-mode of the `ModifyCommand` was implemented (#60):
      - specifying `-a`/`--add` will add the modification value to the field of the entries rather than overwrite it
      - this can be used for string or list concatenation and even number addition on numeric fields


  - use file paths relative to user-home (achieved by replacing `os.path` with `pathlib`) (#69)
  - the shell helper `_list_tags` has been renamed to `_list_labels`
  - (DEV): the `logging` and `zsh_helper` modules have been relocated to the `cobib.utils` package
  - `+` symbols will no longer be stripped from tags (this was a left-over artifact from pre-v1.0.0)


  - the `config.database.format.month` setting is deprecated in favor of proper three-letter code encoding to support common citation style macros (!34)


  - renaming the label during the `edit` command does not leave the previous label entry behind:
      - a followup also ensured that renaming entries happens in-place (#75)
  - the sorting of the `list` command




  Pypi: https://pypi.org/project/cobib/3.0.0/

  - From now on, `coBib` is the official way of spelling!


  - coBib's documentation is now generated by [`pdoc`](https://pdoc.dev/) and hosted at https://cobib.gitlab.io/cobib/cobib.html
  - (DEV): the `cobib.database.Database`-Singleton has been added to centrally manage the bibliographic runtime data (!28)
  - the new option `config.database.format.suppress_latex_warnings`
  - the new option `config.commands.edit.editor` which takes precedence over the `$EDITOR` variable


  - the `INI`-style configuration is replaced with a `Python`-based configuration (#54,!25)
      - for guidance on how to migrate an existing configuration please read https://mrossinek.gitlab.io/programming/cobibs-new-configuration/
  - (DEV): `cobib.parser.Entry` has been moved to `cobib.database.Entry`
  - the `cobib.parsers` module has been extracted (prep for #49, !28)
  - the filenames of the associated files are preserved when exporting to a Zip file
  - when trying to add an entry with an existing label, the database is not written to and a warning is raised early
  - month conversion and special character escaping are only done upon saving entries to the database
  - the path to the default logfile can now be configured via `config.logging.logfile` and defaults to `~/.cache/cobib/cobib.log`


  - the `INI`-style configuration is deprecated
      - new configuration options will not be added to this style
      - only bugs which fully break usability will be fixed with regards to this configuration style
      - legacy-support will be fully removed on 1.1.2022


  - the ZSH helper utilities now respect the `-c`, `-l`, and `-v` command line options
  - the `RedoCommand` should only revert a previously `UndoCommand` operation (#65)
  - the `SearchCommand` got some contexts improvements and correctly splits grep results
  - unwrapping does not crash the TUI if the cursor was multiple lines below the new buffer height
  - line continuation guides are not swallowed by current line highlighting
  - ensure the TUI's top line does not become negative
  - the TUI's handler for resizing events
  - `JSONDecodeError`s thrown by the `ISBNParser` are caught and handled gracefully


  - the functions `read_database()` and `write_database()` are no longer available (!28)




  Pypi: https://pypi.org/project/cobib/2.6.1/

  Note: [2.6.1] was not released from the `master`-branch, which resulted in a non-linear development.


  - `init --git` will not initialize a repository unless git has configured both, `name` and `email`


  - TUI no longer crashes when aborting to quit (#64)




  Pypi: https://pypi.org/project/cobib/2.6.0/


  - Git integration (#44, !20):
      - will automatically track any changes done to the database file with git
      - must be enabled by setting the `DATABASE/git` option to `True` **and** running `cobib init --git`
      - Note, that you must have at least set a `name` and `email` in the git config!
  - Undo/Redo commands to operate on git history of the database (#59,!23)
      - for obvious reasons these commands require the Git integration (see above) to be enabled
  - the `Prompt` command inside of the TUI:
      - allows executing arbitrary CoBib CLI commands
      - the default key binding is `:`
  - the `Modify` command: (#60,!24)
      - allows bulk modification of multiple entries in a `<field>:<value>` format
      - for now, this will **always** overwrite the field with the new value!
      - an extension to appending values is planned for a later release
      - the set of entries to be modified can be specified just like with the `export` command through `list`-command filters or manual selection (by setting the `--selection` flag)


  - the viewport history is preserved correctly (#21,!22)
      - this allows performing a search while showing an entry and reverts back to the correct view after quitting the search
      - the changes mainly involved refactoring of the `cobib/tui` module
  - the **positional** argument of the `modify` and `search` has been renamed internally from `list_arg` to `filter`
      - this should not have any visible effect to an end-user but may be relevant to developers


  - gracefully handle multiple terminal sizing issues with regards to popups (#58)
  - catch messages on `stdout` during deletion from TUI
  - added missing help strings to the TUI help menu


  - The `--force` argument to the `init` command has now been removed (after being deprecated in v2.5.0).




  Pypi: https://pypi.org/project/cobib/2.5.0/


  - support for multiple associated files (#42,!19)
  - interactive menu when opening an entry with multiple associated files (!19)


  - The `--force` argument to the `init` command has been deprecated. I don't think there is any
    benefit to providing the user the option to nuke their database file from the CLI. Instead,
    they can simply edit the file manually.


  - always store years as strings to be compatible with bibtexparser
  - handle invalid arXiv or DOI IDs gracefully (#57)




  Pypi: https://pypi.org/project/cobib/2.4.1/


  - ISBN parser was missing the ENTRYTYPE and did not use strings for number fields
  - the ISBN parser can now handle empty entries (#53)
  - the TUI will not crash on stdout/stderr messages exceeding the window width
  - the TUI respects quoted strings in the prompt handler (#52)




  Pypi: https://pypi.org/project/cobib/2.4.0/


  - the `FORMAT/default_entry_type` option used for manual entry addition
  - a **manual** insertion mode available through `edit -a new_label` and `add -l new_label`
  - a ISBN-based parser for adding new entries (#45)
  - the TUI-based `select` command (and corresponding settings) (#8,!18)
  - the `--selection` argument for the `export` command (!18)


  - TUI color highlighting is now prioritized (!17)


  - support URLs in file field during `open` command (#47)
  - the TUI no longer crashes when encountering long prompt inputs (#48)
  - the `edit` command can handle labels which start with common substrings (#46)
  - support multiple ANSI colors on a single line (#50)




  Pypi: https://pypi.org/project/cobib/2.3.4/


  - another AUR package installation error




  Pypi: https://pypi.org/project/cobib/2.3.3/


  - AUR package installation error



  Pypi: https://pypi.org/project/cobib/2.3.2/


  - option to default to case-insensitive searching (`DATABASE/search_ignore_case`)


  - clearing the prompt, aborts the command execution


  - search command correctly handles missing arguments in TUI (#43)



  Pypi: https://pypi.org/project/cobib/2.3.1/


  - faulty Pypi package



  Pypi: https://pypi.org/project/cobib/2.3.0/


  - Logging functionality has been added. The verbosity level can be controlled via `-v` (INFO) and `-vv` (DEBUG).
    As soon as the TUI starts, all logging output is redirected to `/tmp/cobib.log`.
  - Command line argument `-l` or `--logfile` can be used to specify the output path of the log. This will overwrite the `/tmp/cobib.log` location.
  - the `TUI/scroll_offset` setting was added. It defaults to `3` and behaves similar to Vim's `scrolloff` setting.
  - Configuration validation has been added. This extends the logging functionality to support more runtime debug information.
  - popup window support: stdout and stderr messages are presented in a popup similarly to the help window


  - `-v` command line argument now refers to `--verbose` rather than `--version`
  - Performance of the `add` command has been improved by not refreshing the database when outside of the TUI.


  - bug when resizing causes the window width to become greater than the buffer width (#39)
  - do not escape special characters in labels (#40)
  - avoid special character encoding in file paths



  Pypi: https://pypi.org/project/cobib/2.2.2/


  - current line highlight if viewport is wider than buffer was not correctly reset
  - the `ignore_non_standard_types` setting had no effect



  Pypi: https://pypi.org/project/cobib/2.2.1/


  - when wrapping the TUI lines, indent until after the label column (#26)
  - renamed `default.ini` to `example.ini` in the documentation folder


  - current line highlight after viewport width was not correctly reset
  - correctly convert boolean configuration options (#34)
  - fix crash of TUI in wrap command when viewport is empty (#37)
  - default configuration settings are managed centrally and consistently (#35)




  Pypi: https://pypi.org/project/cobib/2.2.0/


  - allow configuring the program used to `open` associated files
  - prompt user before actually quitting CoBib (#33)
  - implements the Search command (#7, !12)


  - the default value of the `open` command was not set correctly




  Pypi: https://pypi.org/project/cobib/2.1.0/


  - added half- and full-page scrolling (#22)


  - importing from `bibtex` data defaults to **not** ignored non-standard entry types (#28)
  - suppress LaTex encoding warnings except when adding entries (#29)
  - `Search` and `Select` print warnings to the prompt while not implemented


  - `init` command ensures directory of database file exists
  - remove window artifacts after `help` menu is closed (#20)
  - configuration file detection was missing a user home expansion (#31)



  Pypi: https://pypi.org/project/cobib/2.0.0/


  - respect sort order reversing and filter `XOR`ing from the TUI (#18)
  - `edit` command on Mac OS (#19)


  - made `init` command safe against database overwriting
  - TUI: list entries in reverse order by default (config: TUI/reverse_order)




  Pypi: https://pypi.org/project/cobib/2.0.0b4/


  - reset viewport position when updating buffer




  Pypi: https://pypi.org/project/cobib/2.0.0b3/


  - properly assert valid current line number




  Pypi: https://pypi.org/project/cobib/2.0.0b2/


  - fixed TUI startup




  **Warning**: do NOT use! The TUI is broken in this release!

  Pypi: https://pypi.org/project/cobib/2.0.0b1/


  - TUI does not crash when opening an entry with no associated file
  - correctly reset current line positions after filtering and editing




  Pypi: https://pypi.org/project/cobib/2.0.0b0/


  - _internal_: refactored the config into a class
  - centralized the database handling to improve performance (#12,!9)


  - the `Show` command does not break after scrolling the viewport (#13)




  Pypi: https://pypi.org/project/cobib/2.0.0a2/


  - user configuration options for:
      - TUI colors
      - TUI key bindings
      - TUI default list arguments
  - help window highlighting


  - sorting and filtering commands remain persistent when updating the list view




  Pypi: https://pypi.org/project/cobib/2.0.0a1/


  - Added a basic curses-based TUI (#5,!7)


  - _internal_: refactored commands into separate module




  Pypi: https://pypi.org/project/cobib/1.1.0/


  - add `FORMAT.month` configuration option to configure the default type for
      month fields (defaults to `int`) (#3,!4)
  - escape special LaTeX characters (#2,!5)


  - `list` no longer breaks with a `KeyError` when a queried field does not exist
      in any bibliography entry (!2)
  - `--label` can now correctly overwrite the ID (#4,!3)


  - `set_config()` and global `CONFIG` exported to separate module




  Pypi: https://pypi.org/project/cobib/1.0.2/

  Note: this removal is not seen as a MINOR version bump because this is
        essentially a long out-standing bug fix


  - doi extraction from pdf files (476efc4f)
    - also removes the ability to add entries directly via pdf files




  Pypi: https://pypi.org/project/cobib/1.0.1/


  - metadata for pypi




  First MAJOR release. Also available via Pypi: https://pypi.org/project/cobib/1.0.0/
  The project was renamed from `CReMa` to `CoBib`


  - allow sorting the list output (2a5a94f1)
  - crude and slow (!!!) zsh completion (9f28f441)
  - support Darwin's `open` command


  - suppress list output when exporting
  - add used tags to columns when listing
  - sort YAML database entries by keys (d2af42d2)


  - fixed arxiv parser (7ce3726f)




  Note: this release was not marked MAJOR because this is still a WIP and early
        alpha release.


  - complete rewrite to use a plain-text `yaml` database instead of `sqlite3` !1


  - `sqlite3` database





  - initial version with a basic `sqlite3`-based database


  [Unreleased]: https://gitlab.com/cobib/cobib/-/compare/v5.2.2...master
  [5.2.2]: https://gitlab.com/cobib/cobib/-/tags/v5.2.2
  [5.2.1]: https://gitlab.com/cobib/cobib/-/tags/v5.2.1
  [5.2.0]: https://gitlab.com/cobib/cobib/-/tags/v5.2.0
  [5.1.3]: https://gitlab.com/cobib/cobib/-/tags/v5.1.3
  [5.1.2]: https://gitlab.com/cobib/cobib/-/tags/v5.1.2
  [5.1.1]: https://gitlab.com/cobib/cobib/-/tags/v5.1.1
  [5.1.0]: https://gitlab.com/cobib/cobib/-/tags/v5.1.0
  [5.0.1]: https://gitlab.com/cobib/cobib/-/tags/v5.0.1
  [5.0.0]: https://gitlab.com/cobib/cobib/-/tags/v5.0.0
  [4.5.0]: https://gitlab.com/cobib/cobib/-/tags/v4.5.0
  [4.4.0]: https://gitlab.com/cobib/cobib/-/tags/v4.4.0
  [4.3.1]: https://gitlab.com/cobib/cobib/-/tags/v4.3.1
  [4.3.0]: https://gitlab.com/cobib/cobib/-/tags/v4.3.0
  [4.2.0]: https://gitlab.com/cobib/cobib/-/tags/v4.2.0
  [4.1.0]: https://gitlab.com/cobib/cobib/-/tags/v4.1.0
  [4.0.0]: https://gitlab.com/cobib/cobib/-/tags/v4.0.0
  [3.5.5]: https://gitlab.com/cobib/cobib/-/tags/v3.5.5
  [3.5.4]: https://gitlab.com/cobib/cobib/-/tags/v3.5.4
  [3.5.3]: https://gitlab.com/cobib/cobib/-/tags/v3.5.3
  [3.5.2]: https://gitlab.com/cobib/cobib/-/tags/v3.5.2
  [3.5.1]: https://gitlab.com/cobib/cobib/-/tags/v3.5.1
  [3.5.0]: https://gitlab.com/cobib/cobib/-/tags/v3.5.0
  [3.4.0]: https://gitlab.com/cobib/cobib/-/tags/v3.4.0
  [3.3.2]: https://gitlab.com/cobib/cobib/-/tags/v3.3.2
  [3.3.1]: https://gitlab.com/cobib/cobib/-/tags/v3.3.1
  [3.3.0]: https://gitlab.com/cobib/cobib/-/tags/v3.3.0
  [3.2.1]: https://gitlab.com/cobib/cobib/-/tags/v3.2.1
  [3.2.0]: https://gitlab.com/cobib/cobib/-/tags/v3.2.0
  [3.1.1]: https://gitlab.com/cobib/cobib/-/tags/v3.1.1
  [3.1.0]: https://gitlab.com/cobib/cobib/-/tags/v3.1.0
  [3.0.0]: https://gitlab.com/cobib/cobib/-/tags/v3.0.0
  [2.6.1]: https://gitlab.com/cobib/cobib/-/tags/v2.6.1
  [2.6.0]: https://gitlab.com/cobib/cobib/-/tags/v2.6.0
  [2.5.0]: https://gitlab.com/cobib/cobib/-/tags/v2.5.0
  [2.4.1]: https://gitlab.com/cobib/cobib/-/tags/v2.4.1
  [2.4.0]: https://gitlab.com/cobib/cobib/-/tags/v2.4.0
  [2.3.4]: https://gitlab.com/cobib/cobib/-/tags/v2.3.4
  [2.3.3]: https://gitlab.com/cobib/cobib/-/tags/v2.3.3
  [2.3.2]: https://gitlab.com/cobib/cobib/-/tags/v2.3.2
  [2.3.1]: https://gitlab.com/cobib/cobib/-/tags/v2.3.1
  [2.3.0]: https://gitlab.com/cobib/cobib/-/tags/v2.3.0
  [2.2.2]: https://gitlab.com/cobib/cobib/-/tags/v2.2.2
  [2.2.1]: https://gitlab.com/cobib/cobib/-/tags/v2.2.1
  [2.2.0]: https://gitlab.com/cobib/cobib/-/tags/v2.2.0
  [2.1.0]: https://gitlab.com/cobib/cobib/-/tags/v2.1.0
  [2.0.0]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0
  [2.0.0b4]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b4
  [2.0.0b3]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b3
  [2.0.0b2]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b2
  [2.0.0b1]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b1
  [2.0.0b0]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b0
  [2.0.0a2]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0a2
  [2.0.0a1]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0a1
  [1.1.0]: https://gitlab.com/cobib/cobib/-/tags/v1.1.0
  [1.0.2]: https://gitlab.com/cobib/cobib/-/tags/v1.0.2
  [1.0.1]: https://gitlab.com/cobib/cobib/-/tags/v1.0.1
  [1.0.0]: https://gitlab.com/cobib/cobib/-/tags/v1.0.0
  [0.2]: https://gitlab.com/cobib/cobib/-/tags/v0.2
  [0.1]: https://gitlab.com/cobib/cobib/-/tags/v0.1


pkgId: feb22d9691ba95769594654c94ee2c2965f51f9efe5c05f041ef8f2b6a81d728
name: python-cobo-custody
arch: src
version: 0.44
epoch: 0
release: 1
summary: Cobo Custody restful api
url: https://github.com/CoboGlobal/cobo-python-api
rpm_license: Cobo Copyright Reserved
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobo-custody-0.44-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/cobo-custody.svg)](https://pypi.python.org/pypi/cobo-custody)
  [![License: GPL v2](https://img.shields.io/badge/License-GPL_v2-blue.svg)](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)
  [![GitHub Release](https://img.shields.io/github/release/CoboGlobal/cobo-python-api.svg?style=flat)]()


  This repository contains the official Python SDK for Cobo WaaS API, enabling developers to integrate with Cobo's Custodial and/or MPC services seamlessly using the Python programming language.


  To access the API documentation, navigate to the [API references](https://www.cobo.com/developers/api-references/overview/).

  For more information on Cobo's Python SDK, refer to the [Python SDK Guide](https://www.cobo.com/developers/sdks-and-tools/sdks/waas/python).




  Ensure that you have created an account and configured Cobo's Custodial and/or MPC services.
  For detailed instructions, please refer to the [Quickstart](https://www.cobo.com/developers/get-started/overview/quickstart) guide.


  Python 3.7 or newer.


  The source code is only required for those looking to modify the package.
  If you just want to use it, please run the following commands:

  ```sh
  pip install --upgrade cobo-custody
  ```

  Install from source with:

  ```sh
  python setup.py install
  ```






  ```python
  from cobo_custody.signer.local_signer import generate_new_key
  api_secret, api_key = generate_new_key()
  print(api_secret)
  print(api_key)
  ```

  For more information on the API key, please [click here](https://www.cobo.com/developers/api-references/overview/authentication).




  `ApiSigner` can be instantiated through

  ```python
  from cobo_custody.signer.local_signer import LocalSigner
  LocalSigner("API_SECRET")
  ```

  In certain scenarios, the private key may be restricted from export, such as when it is stored in AWS Key Management Service (KMS).
  In such cases, please pass in a custom implementation using the ApiSigner interface:



  ```python
  from cobo_custody.client import Client
  from cobo_custody.config import DEV_ENV
  from cobo_custody.signer.local_signer import LocalSigner
  client = Client(signer=signer, env=DEV_ENV, debug=True)
  ```


  ```python
  from cobo_custody.signer.local_signer import generate_new_key
  from cobo_custody.client import Client
  from cobo_custody.config import DEV_ENV
  from cobo_custody.signer.local_signer import LocalSigner
  api_secret, api_key = generate_new_key()
  singer = LocalSigner("api_secret")
  client = Client(signer=singer, env=DEV_ENV, debug=True)
  res = client.get_account_info()
  print(res)
  ```


pkgId: 88d8a04fa33cf0ae2b4352da75c0bef5e5d3d51a06f20f6ffc626122ced01344
name: python-cobra-io
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Composable Benchmark for Robotics Applications - Input/Output
url: https://pypi.org/project/cobra-io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobra-io-0.0.8-1.src.rpm
checksum_type: sha256
description:
  CoBRA I/O is an interface to the **C**\ omposable **B**\ enchmark for **R**\ obotics **A**\ pplications `(CoBRA) <https://cobra.cps.cit.tum.de>`_.
  With it you can easily upload, download, and interact with CoBRA's robots, tasks and solutions.


pkgId: 480ff156128d499455950d127e95b50ab3c5c3a8662f473b105d665efefcfb22
name: python-cobrafuzz
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Coverage-guided fuzz testing for Python
url: https://pypi.org/project/cobrafuzz/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobrafuzz-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Makefile CI](https://github.com/senier/cobrafuzz/actions/workflows/makefile.yml/badge.svg)](https://github.com/senier/cobrafuzz/actions/workflows/makefile.yml)
  [![CodeQL](https://github.com/senier/cobrafuzz/actions/workflows/codeql.yml/badge.svg)](https://github.com/senier/cobrafuzz/actions/workflows/codeql.yml)

  CobraFuzz is a parallel coverage-guided [fuzzer](https://developer.mozilla.org/en-US/docs/Glossary/Fuzzing) for testing Python programs.
  It is a fork of [pythonfuzz](https://gitlab.com/gitlab-org/security-products/analyzers/fuzzers/pythonfuzz).

  Fuzzing for safe languages like Python is a powerful strategy for finding bugs like unhandled exceptions, logic bugs and security bugs.
  It makes a good addition to classic unit-testing.





  The first step is to implement a function to be fuzz-tested, also called a fuzz target.
  Here is an example of a simple fuzz target for the built-in `html` module

  ```python,examples/fuzz_htmlparser/fuzz.py
  from cobrafuzz.main import CobraFuzz


  @CobraFuzz
  def fuzz(buf: bytes) -> None:
      from html.parser import HTMLParser

      try:
          parser = HTMLParser()
          parser.feed(buf.decode("ascii"))
      except UnicodeDecodeError:
          pass


  if __name__ == "__main__":
      fuzz()
  ```

  Features of a fuzz target:

  * `fuzz()` will call the fuzz target in an infinite loop with random data generated by the coverage-guided algorithm. The data is passed to the target in a separate process through the `buf` parameter.
  * The function must catch and ignore any expected exceptions that arise when passing invalid input to the tested program.
  * The fuzz target must call the test function / library with the passed buffer or a transformation on the test buffer if the structure is different or of different type.
  * Fuzz functions can also implement application level checks to catch application or logical bugs. For example: decode the buffer with the library under test, encode it again, and check that both results are equal. To communicate the result, the fuzz target should throw an exception.
  * CobraFuzz will report any unhandled exceptions as crashes.



  The next step is to download CobraFuzz and then run the fuzzer:

  ```console
  $ pip install cobrafuzz
  [...]

  $ python examples/fuzz_htmlparser/fuzz.py --crash-dir results fuzz --max-crashes 1




  [...]


  Crash dir created (results)
  sample was written to results/crash-c76ab601df7d8513560ad3c1a38f43c715122b342637a4517a32d13dea03d3ce
  sample = 3c215b2119
  Found 1 crashes, stopping.
  ```

  By default, CobraFuzz will use all CPUs available in the system (8 in this example: 1 coordination process and 7 independent workers).
  Use the `-j` / `--num-workers` command line parameter to override the default.
  In this example an unhandled exception is found in a few seconds.



  CobraFuzz will generate and test various inputs in an infinite loop.

  Seeds can be provided as a mix of files and directories by the `seeds` parameter.
  If one of those seeds parameters is a directory, all regular files therein are used as seeds.
  CobraFuzz can also start with an empty seed corpus, though some valid test-cases in the seed corpus may speed up the fuzzing substantially.

  More fuzz target examples (for real and popular libraries) can be found in the examples directory.



  CobraFuzz is a fork of [pythonfuzz](https://gitlab.com/gitlab-org/security-products/analyzers/fuzzers/pythonfuzz).
  pythonfuzz is a port of [fuzzitdev/jsfuzz](https://github.com/fuzzitdev/jsfuzz).
  jsfuzz is in turn heavily based on [go-fuzz](https://github.com/dvyukov/go-fuzz) originally developed by [Dmitry Vyukov](https://twitter.com/dvyukov).
  go-fuzz is in turn heavily based on [Michal Zalewski](https://twitter.com/lcamtuf)'s [AFL](http://lcamtuf.coredump.cx/afl/).



  Contributions are welcome, feel free to open issues and pull requests on GitHub.



  * [python built-in HTMLParser - unhandled exception (pythonfuzz)](https://bugs.python.org/msg355287), [twice](https://bugs.launchpad.net/beautifulsoup/+bug/1883104)
  * [beautifulsoup (pythonfuzz)](https://bugs.launchpad.net/beautifulsoup/+bug/1883264)

  Feel free to add bugs that you found with CobraFuzz to this list via pull requests.


pkgId: 9fdd62f644b3f50e502e2d2cd369bd9259a916246ebbdfe56bdbbf4e3735a31c
name: python-cobs
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Consistent Overhead Byte Stuffing (COBS)
url: https://github.com/cmcqueen/cobs-python
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobs-1.2.1-1.src.rpm
checksum_type: sha256
rpm_license:
  ---------------------------------------------------------------------------- Copyright (c) 2010 Craig McQueen  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ----------------------------------------------------------------------------


pkgId: b537bc5526b654ea694903895ce2ada3399d12c2c0471bd367d0114bed105cd7
name: python-cobweb-launcher
arch: src
version: 1.2.11
epoch: 0
release: 1
summary: spider_hole
url: https://github.com/Juannie-PP/cobweb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobweb-launcher-1.2.11-1.src.rpm
checksum_type: sha256
description:
  cobweb是一个基于python的分布式爬虫调度框架，目前支持分布式爬虫，单机爬虫，支持自定义数据库，支持自定义数据存储，支持自定义数据处理等操作。

  cobweb主要由3个模块和一个配置文件组成：Launcher启动器、Crawler采集器、Pipeline存储和setting配置文件。
  1. Launcher启动器：用于启动爬虫任务，控制爬虫任务的执行流程，以及数据存储和数据处理。
  框架提供两种启动器模式：LauncherAir、LauncherPro，分别对应单机爬虫模式和分布式调度模式。
  2. Crawler采集器：用于控制采集流程、数据下载和数据处理。
  框架提供了基础的采集器，用于控制采集流程、数据下载和数据处理，用户也可在创建任务时自定义请求、下载和解析方法，具体看使用方法介绍。
  3. Pipeline存储：用于存储采集到的数据，支持自定义数据存储和数据处理。框架提供了Console和Loghub两种存储方式，用户也可继承Pipeline抽象类自定义存储方式。
  4. setting配置文件：用于配置采集器、存储器、队列长度、采集线程数等参数，框架提供了默认配置，用户也可自定义配置。

  ```
  pip3 install --upgrade cobweb-launcher
  ```


  - LauncherAir任务创建
  ```python
  from cobweb import LauncherAir


  app = LauncherAir(task="test", project="test")


  app.SEEDS = [{
      "url": "https://www.baidu.com"
  }]
  ...

  app.start()
  ```
  - LauncherPro任务创建
  LauncherPro依赖redis实现分布式调度，使用LauncherPro启动器需要完成环境变量的配置或自定义setting文件中的redis配置，如何配置查看`2. 自定义配置文件参数`
  ```python
  from cobweb import LauncherPro


  app = LauncherPro(
      task="test",
      project="test"
  )
  ...

  app.start()
  ```

  - 通过自定义setting文件，配置文件导入字符串方式
  > 默认配置文件：import cobweb.setting
  > 不推荐！！！目前有bug，随缘使用...
  例如：同级目录下自定义创建了setting.py文件。
  ```python
  from cobweb import LauncherAir

  app = LauncherAir(
      task="test",
      project="test",
      setting="import setting"
  )

  ...

  app.start()
  ```
  - 自定义修改setting中对象值
  ```python
  from cobweb import LauncherPro


  app = LauncherPro(
      task="test",
      project="test",
      REDIS_CONFIG = {
          "host": ...,
          "password":...,
          "port": ...,
          "db": ...
      }
  )
  ...

  app.start()
  ```

  `@app.request`使用装饰器封装自定义请求方法，作用于发生请求前的操作，返回Request对象或继承于BaseItem对象，用于控制请求参数。
  ```python
  from typing import Union
  from cobweb import LauncherAir
  from cobweb.base import Seed, Request, BaseItem

  app = LauncherAir(
      task="test",
      project="test"
  )

  ...

  @app.request
  def request(seed: Seed) -> Union[Request, BaseItem]:
      
      proxies = {"http": ..., "https": ...}
      yield Request(seed.url, seed, ..., proxies=proxies, timeout=15)
      

  ...

  app.start()
  ```
  > 默认请求方法
  > def request(seed: Seed) -> Union[Request, BaseItem]:
  > &nbsp;&nbsp;&nbsp;&nbsp;yield Request(seed.url, seed, timeout=5)

  `@app.download`使用装饰器封装自定义下载方法，作用于发生请求时的操作，返回Response对象或继承于BaseItem对象，用于控制请求参数。
  ```python
  from typing import Union
  from cobweb import LauncherAir
  from cobweb.base import Request, Response, BaseItem

  app = LauncherAir(
      task="test",
      project="test"
  )

  ...

  @app.download
  def download(item: Request) -> Union[BaseItem, Response]:
      ...
      response = ...
      ...
      yield Response(item.seed, response, ...) # 返回Response对象，进行解析
      

  ...

  app.start()
  ```
  > 默认下载方法
  > def download(item: Request) -> Union[Seed, BaseItem, Response, str]:
  > &nbsp;&nbsp;&nbsp;&nbsp;response = item.download()
  > &nbsp;&nbsp;&nbsp;&nbsp;yield Response(item.seed, response, **item.to_dict)

  自定义解析需要由一个存储数据类和解析方法组成。存储数据类继承于BaseItem的对象，规定存储表名及字段，
  解析方法返回继承于BaseItem的对象，yield返回进行控制数据存储流程。
  ```python
  from typing import Union
  from cobweb import LauncherAir
  from cobweb.base import Seed, Response, BaseItem

  class TestItem(BaseItem):
      __TABLE__ = "test_data" # 表名
      __FIELDS__ = "field1, field2, field3" # 字段名

  app = LauncherAir(
      task="test",
      project="test"
  )

  ...

  @app.parse
  def parse(item: Response) -> Union[Seed, BaseItem]:
      ...
      yield TestItem(item.seed, field1=..., field2=..., field3=...)
      

  ...

  app.start()
  ```
  > 默认解析方法
  > def parse(item: Request) -> Union[Seed, BaseItem]:
  > &nbsp;&nbsp;&nbsp;&nbsp;upload_item = item.to_dict
  > &nbsp;&nbsp;&nbsp;&nbsp;upload_item["text"] = item.response.text
  > &nbsp;&nbsp;&nbsp;&nbsp;yield ConsoleItem(item.seed, data=json.dumps(upload_item, ensure_ascii=False))

  - 队列优化完善，使用queue的机制wait()同步各模块执行？
  - 日志功能完善，单机模式调度和保存数据写入文件，结构化输出各任务日志
  - 去重过滤（布隆过滤器等）
  - 单机防丢失
  - excel、mysql、redis数据完善

  > 未更新流程图！！！
  ![img.png](https://image-luyuan.oss-cn-hangzhou.aliyuncs.com/image/D2388CDC-B9E5-4CE4-9F2C-7D173763B6A8.png)


pkgId: 3ec5e4f7b9e062444137ee621e2b0c04c902756fd77ca73dcdc7ce0281343535
name: python-cobyqa
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Constrained Optimization BY Quadratic Approximations
url: https://pypi.org/project/cobyqa/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cobyqa-1.1.1-1.src.rpm
checksum_type: sha256
description:
  COBYQA, an acronym for *Constrained Optimization BY Quadratic Approximations*, is designed to supersede `COBYLA <https://docs.scipy.org/doc/scipy/reference/optimize.minimize-cobyla.html>`_ as a general derivative-free optimization solver.
  It can handle unconstrained, bound-constrained, linearly constrained, and nonlinearly constrained problems.
  It uses only function values of the objective and constraint functions, if any.
  No derivative information is needed.
  **Documentation:** https://www.cobyqa.com.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2021-2024, Tom M. Ragonneau and Zaikun Zhang  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.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  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.


pkgId: 212c6cb6841161985e979f9e6447e6c9f0458e76166e27f98856754154888554
name: python-cochl
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Cochl Sense
url: https://github.com/cochlearai/cochl-sense-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cochl-1.0.0-1.src.rpm
checksum_type: sha256
description:
  `cochl-sense-py` is a Python client library providing easy integration of Cochl.Sense API into any Python application. You can upload a file (MP3, WAV, OGG) or raw PCM audio stream.

  <br/>



  `cochl-sense-py` can be installed and used in Python 3.8+.

  ```python
  pip install --upgrade cochl
  ```

  <br/>



  This simple setup is enough to input your file. API project key can be retrieved from [Cochl Dashboard](https://dashboard.cochl.ai/).

  ```python
  import cochl.sense as sense

  client = sense.Client("YOUR_API_PROJECT_KEY")

  results = client.predict("your_file.wav")
  print(results.to_dict())  # get results as a dict
  ```

  <br/>

  You can adjust the custom settings like below. For more details please refer to [Advanced Cconfigurations](#advanced-configurations).
  ```python
  import cochl.sense as sense

  api_config = sense.APIConfig(
      sensitivity=sense.SensitivityConfig(
          default=sense.SensitivityScale.LOW,
          by_tags={
              "Baby_cry": sense.SensitivityScale.VERY_LOW,
              "Gunshot":  sense.SensitivityScale.HIGH,
          },
      ),
  )

  client = sense.Client(
      "YOUR_API_PROJECT_KEY",
      api_config=api_config,
  )

  results = client.predict("your_file.wav")
  print(results.to_dict())  # get results as a dict
  ```

  <br/>

  The file prediction result can be displayed in a summarized format. More details at [Summarized Result](#summarzied-result).
  ```python


  print(results.to_summarized_result(
      interval_margin=2,
      by_tags={"Baby_cry": 5, "Gunshot": 3}
  ))  # get results in a simplified format


  ```

  <br/>

  Cochl.Sense API supports three file formats: MP3, WAV, OGG. \
  If a file is not in a supported format, it has to be manually converted. More details [here](#convert-to-supported-file-formats-wav-mp3-ogg).


  <br/>





  Detection sensitivity can be adjusted for all tags or each tag individually. \
  If you feel that tags are not detected well enough, increase sensitivities. If there are too many false detections, lower sensitivities.

  The sensitivity is adjusted with `SensitivityScale` Enum.
    - `VERY_HIGH`
    - `HIGH`
    - `MEDIUM` (default)
    - `LOW`
    - `VERY_LOW`

  ```python
  import cochl.sense as sense

  api_config = sense.APIConfig(
      sensitivity=sense.SensitivityConfig(
          
          default=sense.SensitivityScale.LOW,
          by_tags={
              "Baby_cry": sense.SensitivityScale.VERY_LOW,
              "Gunshot":  sense.SensitivityScale.HIGH,
          },
      ),
  )
  client = sense.Client(
      "YOUR_API_PROJECT_KEY",
      api_config=api_config,
  )
  ```

  <br/>
  <br/>





  `Pydub` is one of the easy ways to convert audio file into a supported format (WAV, MP3, OGG).

  First install Pydub refering to this [link](https://github.com/jiaaro/pydub?tab=readme-ov-file#installation). \
  Then write a Python script converting your file into a supported format like below.

  ```python
  from pydub import AudioSegment

  mp4_version = AudioSegment.from_file("sample.mp4", "mp4")
  mp4_version.export("sample.mp3", format="mp3")
  ```

  For more details of `Pydub`, please refer to this [link](https://github.com/jiaaro/pydub).

  <br/>


  You can summarize the file prediction result by aggregating consecutive windows, returning the time and length of the detected tag. \
  The 'interval margin' is a parameter that treats the unrecognized window between tags as part of the recognized ones and it affects all sound tags.
  If you want to specify a different interval margin for specific sound tags, you can use the 'by_tags' option.

  ```python
  print(results.to_summarized_result(
      interval_margin=2,
      by_tags={"Baby_cry": 5, "Gunshot": 3}
  ))


  ```

  <br/>



  Documentation: https://docs.cochl.ai/sense/api/


pkgId: d2f6baf40706f1b640b22e5fed79c4829539ceaf25f18a87d42377ccc29e24c4
name: python-cochl
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Cochl Sense
url: https://github.com/cochlearai/cochl-sense-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cochl-1.0.10-1.src.rpm
checksum_type: sha256
description:
  `cochl-sense-py` is a Python client library providing easy integration of Cochl.Sense API into any Python application. You can upload a file (MP3, WAV, OGG) or raw PCM audio stream.

  <br/>



  `cochl-sense-py` can be installed and used in Python 3.9+.

  ```python
  pip install --upgrade cochl
  ```

  <br/>



  This simple setup is enough to input your file. API project key can be retrieved from [Cochl Dashboard](https://dashboard.cochl.ai/).

  ```python
  import cochl.sense as sense

  client = sense.Client("YOUR_API_PROJECT_KEY")

  results = client.predict("your_file.wav")
  print(results.to_dict())  # get results as a dict
  ```

  <br/>

  You can adjust the custom settings like below. For more details please refer to [Advanced Cconfigurations](#advanced-configurations).
  ```python
  import cochl.sense as sense

  api_config = sense.APIConfig(
      sensitivity=sense.SensitivityConfig(
          default=sense.SensitivityScale.LOW,
          by_tags={
              "Baby_cry": sense.SensitivityScale.VERY_LOW,
              "Gunshot":  sense.SensitivityScale.HIGH,
          },
      ),
  )

  client = sense.Client(
      "YOUR_API_PROJECT_KEY",
      api_config=api_config,
  )

  results = client.predict("your_file.wav")
  print(results.to_dict())  # get results as a dict
  ```

  <br/>

  The file prediction result can be displayed in a summarized format. More details at [Summarized Result](#summarzied-result).
  ```python


  print(results.to_summarized_result(
      interval_margin=2,
      by_tags={"Baby_cry": 5, "Gunshot": 3}
  ))  # get results in a simplified format


  ```

  <br/>

  Cochl.Sense API supports three file formats: MP3, WAV, OGG. \
  If a file is not in a supported format, it has to be manually converted. More details [here](#convert-to-supported-file-formats-wav-mp3-ogg).


  <br/>





  Detection sensitivity can be adjusted for all tags or each tag individually. \
  If you feel that tags are not detected well enough, increase sensitivities. If there are too many false detections, lower sensitivities.

  The sensitivity is adjusted with `SensitivityScale` Enum.
    - `VERY_HIGH`
    - `HIGH`
    - `MEDIUM` (default)
    - `LOW`
    - `VERY_LOW`

  ```python
  import cochl.sense as sense

  api_config = sense.APIConfig(
      sensitivity=sense.SensitivityConfig(
          
          default=sense.SensitivityScale.LOW,
          by_tags={
              "Baby_cry": sense.SensitivityScale.VERY_LOW,
              "Gunshot":  sense.SensitivityScale.HIGH,
          },
      ),
  )
  client = sense.Client(
      "YOUR_API_PROJECT_KEY",
      api_config=api_config,
  )
  ```

  <br/>
  <br/>





  `Pydub` is one of the easy ways to convert audio file into a supported format (WAV, MP3, OGG).

  First install Pydub refering to this [link](https://github.com/jiaaro/pydub?tab=readme-ov-file#installation). \
  Then write a Python script converting your file into a supported format like below.

  ```python
  from pydub import AudioSegment

  mp4_version = AudioSegment.from_file("sample.mp4", "mp4")
  mp4_version.export("sample.mp3", format="mp3")
  ```

  For more details of `Pydub`, please refer to this [link](https://github.com/jiaaro/pydub).

  <br/>


  You can summarize the file prediction result by aggregating consecutive windows, returning the time and length of the detected tag. \
  The 'interval margin' is a parameter that treats the unrecognized window between tags as part of the recognized ones and it affects all sound tags.
  If you want to specify a different interval margin for specific sound tags, you can use the 'by_tags' option.

  ```python
  print(results.to_summarized_result(
      interval_margin=2,
      by_tags={"Baby_cry": 5, "Gunshot": 3}
  ))


  ```

  <br/>



  Documentation: https://docs.cochl.ai/sense/api/


pkgId: e75960a18d69fac2a5ed681fa057633ce376ca49cb1b758740e6001562470538
name: python-cochl-sense-api
arch: src
version: 1.7.9
epoch: 0
release: 1
summary: Cochl Sense API
url: https://github.com/cochlearai/sense-api-samples
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cochl-sense-api-1.7.9-1.src.rpm
checksum_type: sha256
description:
  *AudioSessionApi* | [**create_session**](docs/AudioSessionApi.md#create_session) | **POST** /audio_sessions/ | Create Session
  *AudioSessionApi* | [**delete_session**](docs/AudioSessionApi.md#delete_session) | **DELETE** /audio_sessions/{session_id} | Delete Session
  *AudioSessionApi* | [**get_results**](docs/AudioSessionApi.md#get_results) | **GET** /audio_sessions/{session_id}/results | Get File Result
  *AudioSessionApi* | [**predict**](docs/AudioSessionApi.md#predict) | **POST** /audio_sessions/{session_id}/predict | Predict
  *AudioSessionApi* | [**read_status**](docs/AudioSessionApi.md#read_status) | **GET** /audio_sessions/{session_id}/status | Read Status
  *AudioSessionApi* | [**update_session**](docs/AudioSessionApi.md#update_session) | **PATCH** /audio_sessions/{session_id} | Update Session
  *AudioSessionApi* | [**upload_chunk**](docs/AudioSessionApi.md#upload_chunk) | **PUT** /audio_sessions/{session_id}/chunks/{chunk_sequence} | Upload Chunk

   - [AudioChunk](docs/AudioChunk.md)
   - [CreateSession](docs/CreateSession.md)
   - [CreatedSession](docs/CreatedSession.md)
   - [DefaultSensitivity](docs/DefaultSensitivity.md)
   - [GenericError](docs/GenericError.md)
   - [Page](docs/Page.md)
   - [PredictRequest](docs/PredictRequest.md)
   - [PredictResponse](docs/PredictResponse.md)
   - [Sense](docs/Sense.md)
   - [SenseEvent](docs/SenseEvent.md)
   - [SenseEventTag](docs/SenseEventTag.md)
   - [SessionRefs](docs/SessionRefs.md)
   - [SessionResult](docs/SessionResult.md)
   - [SessionStatus](docs/SessionStatus.md)
   - [SessionType](docs/SessionType.md)
   - [TagsSensitivity](docs/TagsSensitivity.md)
   - [UpdateSession](docs/UpdateSession.md)


  - **Type**: API key
  - **API key parameter name**: x-api-key
  - **Location**: HTTP header

  support@cochl.ai

  If the OpenAPI document is large, imports in cochl_sense_api.apis and cochl_sense_api.models may fail with a
  RecursionError indicating the maximum recursion limit has been exceeded. In that case, there are a couple of solutions:
  Solution 1:
  Use specific imports for apis and models like:
  - `from cochl_sense_api.api.default_api import DefaultApi`
  - `from cochl_sense_api.model.pet import Pet`
  Solution 2:
  Before importing the package, adjust the maximum recursion limit as shown below:
  ```
  import sys
  sys.setrecursionlimit(1500)
  import cochl_sense_api
  from cochl_sense_api.apis import *
  from cochl_sense_api.models import *
  ```


pkgId: 5c9d015bd7362dd466c87d393ef54532c0b06c3a5cb372c0a8d35cd823e8403a
name: python-cockroachdb
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: CockroachDB adapter for SQLAlchemy
url: https://github.com/cockroachdb/cockroachdb-python
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cockroachdb-0.3.5-1.src.rpm
checksum_type: sha256
description:
  This package has changed names.

  Please use [sqlalchemy-cockroachdb](https://pypi.org/project/sqlalchemy-cockroachdb/).


pkgId: 603459a972ef50e02912999807d6a8c0bd403f3dee713313feebe82055abff8b
name: python-cocnc
arch: src
version: 0.2.29
epoch: 0
release: 1
url: https://github.com/coherenceplatform/cnc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocnc-0.2.29-1.src.rpm
checksum_type: sha256
summary:
  CNC is the first framework for application deployment, a fully distributed and customizable PaaS developer experience, based on docker-compose config files

description:
  <p align="center">
  <picture>
    <source srcset="https://cncframework.com/images/cnc_logo_white.svg" media="(prefers-color-scheme: dark)">
    <source srcset="https://cncframework.com/images/cnc_logo_black.svg" media="(prefers-color-scheme: light)">
    <img src="https://cncframework.com/images/cnc_logo_black.svg" alt="cnc logo" width="200" height="auto">
  </picture>
  </p>





  `cnc` is an open-source framework that equips developers with the right tools to deploy applications with precision. Rooted in the principles of Infrastructure as Code (IaC) using terraform, `cnc` translates high level service definitions into reference architecture based infrastructure across various environments — whether it’s for development, staging, production, or ephemeral environments. For those who have used AWS's Amplify CLI, think of `cnc` as a broader, adaptable framework that supports your unique deployment needs.

  Core Lifecycle Events Managed by `cnc`:

  - Provision: Uses terraform to create, manage, and dismantle cloud resources, ensuring each environment is crafted to fit its specific purpose.
  - Build: Assembles the necessary deployment artifacts for each environment, from docker containers to static assets for web applications.
  - Deploy: Seamlessly updates infrastructure to deploy new artifacts, such as modifying k8s manifests or updating ECS services.
  - Toolbox: A `toolbox` is a managed shell against a `cnc`-managed environment, making it easy to get a REPL or run database migrations, for example

  Getting Started with `cnc`:

  - Experience `cnc` in just a few minutes: install and see for yourself the power of cnc in under 5 minutes without needing any cloud permissions or incurring any costs.
  - Rapid Deployment: Have your first environment up and running in less than 15 minutes, demonstrating the straightforward power of cnc.

  `cnc` is designed to be a powertool that empowers you to build and manage your infrastructure with the same attention to detail and creativity that you bring to your code. Just like web devs use frameworks to build better products, with `cnc`, you gain the freedom to implement your vision precisely as intended, making each project not only functional but finely tuned to your standards.





  Intall `cnc` from the [PyPI Python Package Index](https://pypi.org/project/cocnc/). For example, using `pip`:
  ```
  pip install cocnc
  ```



  You can make a new directory, nothing but the following 2 files is needed by `cnc`. Save as `cnc.yml`:

  ```yaml
  services:
    app:
      command: "my command"
      x-cnc:
        type: backend
      build:
        context: .
    db:
      x-cnc:
        type: database
        version: 15
      image: postgres
  ```

  Save as environments.yml:

  ```yaml
  name: my-first-app
  provider: gcp
  flavor: run-lite
  version: 1

  collections:
  - name: dev
    region: us-east1
    base_domain: mydevsite.com
    account_id: "foo-bar-123"
    environments:
    - name: dev
      environment_variables:
      - name: FOO
        value: bar
  ```

  `cnc` has robust environment configuration options, including support for environment variables from cloud secrets, terraform outputs, or aliasing from other variables. Read more about configuration [here](https://cncframework.com/configuration/overview/).




  All this will do is manipulate text files in your `/tmp` directory and won't actually touch anything in your code or cloud. It's the best way to get to `Aha!` quickly before diving in deeper.

  ```



  cnc provision debug --no-cleanup



  cnc build perform dev --debug --no-cleanup


  cnc deploy perform dev --debug --no-cleanup
  ```

  Add a 2nd environment (e.g. `dev2`) to the `environments.yml` and run the commands again, see the power of the framework!



  Access full documentation and in-depth tutorials at [the CNC Documentation](https://cncframework.com).



  - Issues: Report bugs or suggest features via GitHub Issues.
  - Support: For direct support, contact our team at cnc@withcoherence.com.



  Interested in contributing to CNC? Check out our Developers Getting Started guide for guidelines and project setup instructions.


pkgId: 444cc29bff5d4e49554df2baef141e04cd535fec11a1d5c06296dc3e10dddde8
name: python-coco-froc-analysis
arch: src
version: 0.2.15
epoch: 0
release: 1
summary: FROC analysis for COCO detections for Detectron(2) and OpenMMLab
url: https://pypi.org/project/coco-froc-analysis/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coco-froc-analysis-0.2.15-1.src.rpm
checksum_type: sha256
description:
  FROC analysis for COCO annotations and Detectron(2) detection results. The COCO annotation style is defined [here](https://cocodataset.org/).



  ```bash
  pip install coco-froc-analysis
  ```



  A single annotation record in the ground-truth file might look like this:

  ```json
  {
    "area": 2120,
    "iscrowd": 0,
    "bbox": [111, 24, 53, 40],
    "category_id": 3,
    "ignore": 0,
    "segmentation": [],
    "image_id": 407,
    "id": 945
  }
  ```

  While the prediction (here for bounding box) given by the region detection framework is such:

  ```json
  {
    "image_id": 407,
    "category_id": 3,
    "score": 0.9990422129631042,
    "bbox": [
      110.72555541992188, 13.9161834716797, 49.4566650390625, 36.65155029296875
    ]
  }
  ```

  The FROC analysis counts the number of images, number of lesions in the ground truth file for all categories and then counts the lesion localization predictions and the non-lesion localization predictions. A lesion is localized by default if its center is inside any ground truth box and the categories match or if you wish to use IoU you should provide threshold upon which you can define the 'close enough' relation.



  ```python
  from coco_froc_analysis.count import generate_bootstrap_count_curves
  from coco_froc_analysis.count import generate_count_curve
  from coco_froc_analysis.froc import generate_bootstrap_froc_curves
  from coco_froc_analysis.froc import generate_froc_curve


  generate_froc_curve(
              gt_ann=args.gt_ann,
              pr_ann=args.pr_ann,
              use_iou=args.use_iou,
              iou_thres=args.iou_thres,
              n_sample_points=args.n_sample_points,
              plot_title='FROC' if args.plot_title is None else args.plot_title,
              plot_output_path='froc.png' if args.plot_output_path is None else args.plot_output_path,
              test_ann=args.test_ann,
          )


  generate_bootstrap_froc_curves(
              gt_ann=args.gt_ann,
              pr_ann=args.pr_ann,
              n_bootstrap_samples=args.bootstrap,
              use_iou=args.use_iou,
              iou_thres=args.iou_thres,
              n_sample_points=args.n_sample_points,
              plot_title='FROC (bootstrap)' if args.plot_title is None else args.plot_title,
              plot_output_path='froc_bootstrap.png' if args.plot_output_path is None else args.plot_output_path,
              test_ann=args.test_ann,
          )
  ```

  Please check `run.py` for more details. The `IoU` part of this code is not reliable and currently the codebase only works for binary evaluation, but any multiclass problem could be chunked up to work with it.

  Description of `run.py` arguments:

  ```bash
  usage: run.py [-h] [--bootstrap BOOTSTRAP] --gt_ann GT_ANN --pr_ann PR_ANN [--use_iou] [--iou_thres IOU_THRES] [--n_sample_points N_SAMPLE_POINTS]
                [--plot_title PLOT_TITLE] [--plot_output_path PLOT_OUTPUT_PATH] [--test_ann TEST_ANN] [--counts] [--weighted]

  optional arguments:
    -h, --help            show this help message and exit
    --bootstrap BOOTSTRAP
                          Whether to do a single or bootstrap runs.
    --gt_ann GT_ANN
    --pr_ann PR_ANN
    --use_iou             Use IoU score to decide based on `proximity`
    --iou_thres IOU_THRES
                          If IoU score is used the default threshold is set to .5
    --n_sample_points N_SAMPLE_POINTS
                          Number of points to evaluate the FROC curve at.
    --plot_title PLOT_TITLE
    --plot_output_path PLOT_OUTPUT_PATH
    --test_ann TEST_ANN   Extra ground-truth like annotations
    --counts
    --weighted
  ```



  ```bash
  python -m coco_froc_analysis [-h] [--bootstrap N_BOOTSTRAP_ROUNDS] --gt_ann GT_ANN --pred_ann PRED_ANN [--use_iou] [--iou_thres IOU_THRES] [--n_sample_points N_SAMPLE_POINTS]
                          [--plot_title PLOT_TITLE] [--plot_output_path PLOT_OUTPUT_PATH]

  optional arguments:
    -h, --help            show this help message and exit
    --bootstrap  N_ROUNDS Whether to do a single or bootstrap runs.
    --gt_ann GT_ANN
    --pred_ann PRED_ANN
    --use_iou             Use IoU score to decide on `proximity` rather then using center pixel inside GT box.
    --iou_thres IOU_THRES
                          If IoU score is used the default threshold is arbitrarily set to .5
    --n_sample_points N_SAMPLE_POINTS
                          Number of points to evaluate the FROC curve at.
    --plot_title PLOT_TITLE
    --plot_output_path PLOT_OUTPUT_PATH
  ```

  By default centroid closeness is used, if the `--use_iou` flag is set, `--iou_thres` defaults to `.75` while the `--score_thres` score defaults to `.5`. The code outputs the FROC curve on the given detection results and GT dataset.





  In order to develop this repository you are in need of `poetry`. To install the latest version of `poetry` please run:

  ```bash
  curl -sSL https://install.python-poetry.org | python3 -
  ```

  After that you can install the dependencies by running:

  ```bash
  poetry install
  ```

  This will install the dependencies and the package in the virtual environment that you can activate by running:

  ```bash
  poetry shell
  ```

  In order to have checks ready before pushing you should also install `pre-commit`:

  ```bash
  pre-commit install
  ```



  ```bash
  python -m coverage run -m unittest discover --pattern "*_test.py" -v
  python -m coverage report -m
  ```



  Install `act` following the instructions [here](https://nektosact.com/installation/index.html).

  ```bash
  curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/nektos/act/master/install.sh | sudo bash
  ```

  Then you can run the GitHub Actions locally by running:

  ```bash
  act
  ```

  This will always fail at the last step because the repository needs the `CODECOV_TOKEN` to be set in the repository secrets. This is not present locally, but this is not an ERROR.



  ```bash
  pdoc -d google coco_froc_analysis -o docs # build docs
  ```

  @Regards, Alex

  ```
  @misc{qbeer,
    author       = {Alex Olar, Botond Koroknai},
    title        = {FROC analysis for COCO-like file format},
    howpublished = {GitHub repository},
    month        = {September},
    year         = {2022},
    url          = {https://github.com/qbeer/coco-froc-analysis}
  }
  ```


pkgId: 54c25a03c0fce92c608d4878d5ef72361cb7d029330464db400f4d2ac3129d02
name: python-coco-tools
arch: src
version: 0.19
epoch: 0
release: 1
summary: TRS-80 Color Computer Tools
url: https://github.com/jamieleecho/coco-tools
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coco-tools-0.19-1.src.rpm
checksum_type: sha256
description:
  This is a simple collection of tools to assist with developing software for
  the [TRS-80 Color Computer](https://en.wikipedia.org/wiki/TRS-80_Color_Computer).



  ```

  pip install coco-tools


  git clone https://github.com/jamieleecho/coco-tools.git
  cd coco-tools
  python3 setup.py
  ```





  ```
  usage: decb-to-b09 [-h] [--version] [-l] [-z] [-s DEFAULT_STRING_STORAGE] [-D] [-w]
                     [-c CONFIG_FILE]
                     program.bas program.b09

  Convert a Color BASIC program to a BASIC09 program
  Copyright (c) 2023 by Jamie Cho
  Version: 0.18

  positional arguments:
    program.bas           input DECB text program file
    program.b09           output BASIC09 text program file

  optional arguments:
    -h, --help            show this help message and exit
    --version             show program's version number and exit
    -l, --filter-unused-linenum
                          Filter out line numbers not referenced by the program
    -z, --dont-initialize-vars
                          Don't pre-initialize all variables
    -s DEFAULT_STRING_STORAGE, --default-string-storage DEFAULT_STRING_STORAGE
                          Bytes to allocate for each string
    -D, --dont-output-dependencies
                          Don't output required dependencies
    -w, --dont-run-width-32
                          if set don't run the default width 32
    -c CONFIG_FILE, --config-file CONFIG_FILE
                          Optional compiler configuration file
  ```



  ```
  usage: cm3toppm [-h] [--version] [image.cm3] [image.ppm]

  Convert RS-DOS CM3 images to PPM
  Copyright (c) 2017 by Mathieu Bouchard
  Copyright (c) 2018-2020 by Jamie Cho
  Version: 0.6

  positional arguments:
    image.cm3   input CM3 image file
    image.ppm   output PPM image file

  options:
    -h, --help  show this help message and exit
    --version   show program's version number and exit
  ```



  ```
  usage: hrstoppm [-h] [-w width] [-r height] [-s bytes] [--version]
                  [image.hrs] [image.ppm]

  Convert RS-DOS HRS images to PPM
  Copyright (c) 2018 by Mathieu Bouchard
  Copyright (c) 2018-2020 by Jamie Cho
  Version: 0.6

  positional arguments:
    image.hrs   input HRS image file
    image.ppm   output PPM image file

  options:
    -h, --help  show this help message and exit
    -w width    choose different width (this does not assume bigger pixels)
    -r height   choose height not computed from header divided by width
    -s bytes    skip some number of bytes
    --version   show program's version number and exit
  ```



  ```
  usage: maxtoppm [-h] [--version]
                  [-br | -rb | -br2 | -rb2 | -br3 | -rb3 | -s10 | -s11] [-i]
                  [-w width] [-r height] [-s bytes] [-newsroom]
                  [image] [image.ppm]

  Convert RS-DOS MAX and ART images to PPM
  Copyright (c) 2018 by Mathieu Bouchard
  Copyright (c) 2018-2020 by Mathieu Bouchard, Jamie Cho
  Version: 0.6

  positional arguments:
    image       input image file
    image.ppm   output PPM image file

  options:
    -h, --help  show this help message and exit
    --version   show program's version number and exit

  pixel mode:
    Default pixel mode is no artifact (PMODE 4 on monitor). The 6 other modes:

    -br         PMODE 4 artifacts, cyan-blue first
    -rb         PMODE 4 artifacts, orange-red first
    -br2        PMODE 3 Coco 3 cyan-blue first
    -rb2        PMODE 3 Coco 3 orange-red first
    -br3        PMODE 3 Coco 3 primary, blue first
    -rb3        PMODE 3 Coco 3 primary, red first
    -s10        PMODE 3 SCREEN 1,0
    -s11        PMODE 3 SCREEN 1,1

  Format and size options::
    Default file format is CocoMax 1/2's .MAX, which is also Graphicom's
    .PIC and SAVEM of 4 or 8 pages of PMODE 3/4.
    Also works with any other height of SAVEM (including fractional pages).

    -i          ignore header errors (but read header anyway)
    -w width    choose different width (this does not assume bigger pixels)
    -r height   choose height not computed from header divided by width
    -s bytes    skip header and assume it has the specified length
    -newsroom   read Coco Newsroom / The Newspaper .ART header instead
  ```



  ```
  usage: mgetoppm [-h] [--version] [image.mge] [image.ppm]

  Convert RS-DOS MGE images to PPM
  Copyright (c) 2017 by Mathieu Bouchard
  Copyright (c) 2018-2020 by Jamie Cho
  Version: 0.6

  positional arguments:
    image.mge   input MGE image file
    image.ppm   output PPM image file

  options:
    -h, --help  show this help message and exit
    --version   show program's version number and exit
  ```



  ```
  usage: mge_viewer2 [-h] [--version] [image.mge]

  View ColorMax 3 MGE files
  Copyright (c) 2022 by R. Allen Murphey
  Version: 0.6

  positional arguments:
    image.mge   input MGE image file

  optional arguments:
    -h, --help  show this help message and exit
    --version   show program's version number and exit
  ```



  ```
  usage: pixtopgm [-h] [--version] image.pix [image.pgm]

  Convert RS-DOS PIX images to PGM
  Copyright (c) 2018-2020 by Mathieu Bouchard, Jamie Cho
  Version: 0.6

  positional arguments:
    image.pix   input PIX image file
    image.pgm   output PGM image file

  options:
    -h, --help  show this help message and exit
    --version   show program's version number and exit
  ```



  ```
  usage: rattoppm [-h] [--version] [image.rat] [image.ppm]

  Convert RS-DOS RAT images to PPM
  Copyright (c) 2018-2020 by Mathieu Bouchard, Jamie Cho
  Version: 0.6

  positional arguments:
    image.rat   input RAT image file
    image.ppm   output PPM image file

  options:
    -h, --help  show this help message and exit
    --version   show program's version number and exit
  ```



  ```
  usage: veftopng [-h] [--version] image.vef image.png

  Convert OS-9 VEF images to PNG
  Copyright (c) 2018-2020  Travis Poppe <tlp@lickwid.net>
  Copyright (c) 2020  Jamie Cho
  Version: 0.6

  positional arguments:
    image.vef   input VEF image file
    image.png   output PNG image file

  options:
    -h, --help  show this help message and exit
    --version   show program's version number and exit
  ```



  ```

  docker-compose build test


  docker-compose run test


  docker-compose run testv


  pip install -r requirements.txt
  pre-commit install
  ```


  The programs in the examples/decb and examples/other-decb-examples-to-try directories are from the following sources:
  * alien4k0.bas -- https://github.com/jggames/trs80mc10/blob/9df4c9578250009d68a03101d626faa3c22e7445/quicktype/Arcade/4K/Alien4K/ALIEN4K0.TXT#L4
  * bach.bas -- https://colorcomputerarchive.com/repo/MC-10/Software/Books/TRS-80%20Color%20Computer%20%26%20MC-10%20Programs/bach.c10
  * banner.bas -- https://colorcomputerarchive.com/repo/MC-10/Software/Books/TRS-80%20Color%20Computer%20%26%20MC-10%20Programs/banner.c10
  * cadnza.bas -- https://colorcomputerarchive.com/repo/MC-10/Software/Books/TRS-80%20Color%20Computer%20%26%20MC-10%20Programs/cadnza.c10
  * cflip.bas -- https://colorcomputerarchive.com/repo/MC-10/Software/Books/TRS-80%20Color%20Computer%20%26%20MC-10%20Programs/cflip.c10
  * flip.bas -- https://github.com/daftspaniel/RetroCornerRedux/blob/main/Dragon/Originals/FlipBits/flip.bas
  * loops.bas -- https://colorcomputerarchive.com/repo/Documents/Manuals/Hardware/Color%20Computer%203%20Extended%20Basic%20(Tandy).pdf
  * f15eagle.bas -- https://colorcomputerarchive.com/repo/Disks/Magazines/Rainbow%20On%20Disk.zip
  * mars.bas -- https://github.com/jggames/trs80mc10/tree/9df4c9578250009d68a03101d626faa3c22e7445/quicktype/Text%20Adventures/WorkInProgress/Mars
  * saints.bas -- https://colorcomputerarchive.com/repo/Documents/Manuals/Hardware/Color%20Computer%203%20Extended%20Basic%20(Tandy).pdf


pkgId: caae30427ab28b00894c9d37c457dcb3b2dcf3aec340bf23eea8d6c7e2c0e85b
name: python-cocoa-vanilla
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A Pythonic wrapper around Cocoa.
url: https://github.com/robotools/vanilla
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocoa-vanilla-0.6.0-1.src.rpm
checksum_type: sha256
description:
  A Pythonic wrapper around Cocoa.

  Documentation is at [vanilla.robotools.dev](http://vanilla.robotools.dev/en/latest/).

  Install for your own use with pip:

      $ pip install cocoa-vanilla

  ([RoboFont](https://robofont.com/) and [DrawBot](https://drawbot.com/) use and bundle cocoa-vanilla.)


pkgId: 2c3ab47fece9b7cc35a87b026d2d4fb7c7b70a098958691e6c5f7c881b05eb70
name: python-cocomltools
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cocomltools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocomltools-0.1.7-1.src.rpm
checksum_type: sha256
description:
  COCO ML Toolbox is a command-line interface (CLI) tool for managing COCO (Common Objects in Context) dataset files. This toolbox provides functionalities to split, merge, and crop COCO datasets, making it easier to manipulate and prepare datasets for machine learning tasks.



  - **Split** a COCO dataset into training and testing datasets with a specified ratio.
  - **Merge** multiple COCO dataset files into a single file.
  - **Crop** images based on annotations in a COCO dataset.


  You can use our streamlit app [here](https://coco-ml-toolbox.streamlit.app/).

  cocomltools requires python >= 3.9.8

  The easiest way to install the package is using pip

  ```
  pip install cocomltools
  ```


  You can also clone the source code and install dependencies using poetry:

  ```bash
  git clone https://github.com/Ghallabi/coco-ml-toolbox.git
  cd coco-ml-toolbox
  pip install poetry
  poetry install
  ```



  The main script for the COCO ML Toolbox provides three commands: split, merge, and crop. Below are the details on how to use each command.



  Splits a COCO dataset into training and testing datasets.

  ```bash
  python main_cli.py split --coco-path /path/to/coco.json --output-dir /path/to/output --ratio 0.2 --mode random
  ```

  * --coco-path: Path to the COCO file (JSON).
  * --output-dir: (Optional) Path to save the split COCO files. Defaults to the directory of the input COCO file.
  * --ratio: (Optional) Split ratio. Defaults to 0.2.
  * --mode: (Optional) Split mode. Options are `random` and `strat`. Defaults to random.




  Merges multiple COCO dataset files into a single file.

  ```bash
  python main_cli.py merge --coco-paths /path/to/coco1.json,/path/to/coco2.json --output-dir /path/to/output
  ```

  * --coco-paths: Comma-separated paths to the COCO files (JSON).
  * --output-dir: (Optional) Path to save the merged COCO file. Defaults to the directory of the first input COCO file.


  Crops images based on annotations in a COCO dataset.

  ```bash
  python main_cli.py crop --coco-path /path/to/coco.json --images-dir /path/to/images --output-dir /path/to/cropped_images --num-workers MAX_WORKERS
  ```

  * --coco-path: Path to the COCO file (JSON).
  * --images-dir: Path to the directory containing the COCO image files.
  * --output-dir: (Optional) Path to save the cropped images. Defaults to a "cropped" directory within the parent directory of the images.
  * --num-workers: to speed up the cropping process.


pkgId: 6d065562457128d40de54611556167118fc61a3fc6b52ba0a9587f53f685a3ff
name: python-cocomo
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Simple wrapper around SLOCCount
url: https://github.com/chintal/cocomo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocomo-0.3.1-1.src.rpm
checksum_type: sha256
description:
  A simple wrapper, essentially implementing the details written out
  by David A. Wheeler and relying on his SLOCCount binary to do all
  the heavy lifting. http://www.dwheeler.com/sloccount/sloccount.html


pkgId: 90c111094328f01cc1ffdbe915ea7e6e879fb158cc99effdbab850a2e5a0729c
name: python-coconutpy
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: A python wrapper around the Coconut API
url: https://coconut.co
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coconutpy-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Client Library for encoding Videos with Coconut

  Coconut is a Video Encoding Web Service built for developers.

  For more information:

  * Coconut: https://coconut.co
  * API Documentation: https://docs.coconut.co
  * Twitter: @openCoconut

  Changelogs

  3.0.0
  New pytonh library compatible with Coconut APIv2

  2.4.3
  Fix Authorization Header:
  "TypeError: a bytes-like object is required, not 'str'" was returned before

  2.4.2
  Don't wait for a 401 challenge to pass the auth token to Coconut APIs.

  2.4.0
  Implements new Job methods to get info about a job and get metadata (new metadata API).

  2.2.0
  Added a new method #config to generate a full configuration based on the given parameters. It's especially useful to handle dynamic settings like source or variables that can be set directly in code.

  2.0.0
  New version of the client library which uses the HeyWatch API v2. This library is not compatible with 1.x

  1.0.0
  First version


pkgId: 8708cb3384db7b74321a4adffdc06e4304a5430e301c3792fd1ff751bc6a44d5
name: python-cocorepr
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: COCO Dataset cleaning tool
url: https://github.com/neuro-inc/cocorepr
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocorepr-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This is a regular format for a COCO dataset: all the annotations are stored in a single json file:
  ```json5
  $ cat examples/coco_chunk/json_file/instances_train2017_chunk3x2.json
  {
      "licenses": [
          {
              "url": "http://creativecommons.org/licenses/by-nc-sa/2.0/",
              "id": 1,
              "name": "Attribution-NonCommercial-ShareAlike License"
          },
      ],
      "info": {
          "description": "COCO 2017 Dataset",
          "url": "http://cocodataset.org",
          "version": "1.0",
          "year": 2017,
          "contributor": "COCO Consortium",
          "date_created": "2017/09/01"
      },
      "categories": [
          {
              "supercategory": "person",
              "id": 1,
              "name": "person"
          },
      ],
      "images": [
          {
              "license": 6,
              "file_name": "000000049428.jpg",
              "coco_url": "http://images.cocodataset.org/train2017/000000049428.jpg",
              "height": 427,
              "width": 640,
              "date_captured": "2013-11-15 04:30:29",
              "flickr_url": "http://farm7.staticflickr.com/6014/5923365195_bee5603371_z.jpg",
              "id": 49428
          },
      ],
      "annotations": [
          {
              "image_id": 140006,
              "bbox": [
                  496.52,
                  125.94,
                  143.48,
                  113.54
              ],
              "category_id": 2,
              "id": 124710
          },
      ]
  }
  ```
  This format is used by many ML frameworks as input format, but usually the json tree file is too big to be stored in a Git repository (over 50M), therefore we either need to store it under Git LFS (which does not show the diff, only the hash), or to use another representation that are better adapted for work with Git.

  This format makes the dataset suitable for Git: it stores each element in a separate json chunk, thus enabling Git to do the diff at the level of individual chunks.
  ```
  $ cocorepr \
      --in_json_file examples/coco_chunk/json_file/instances_train2017_chunk3x2.json \
      --out_path $TMP \
      --out_format json_tree  # --overwrite
  INFO:root:Arguments: Namespace(in_crop_tree_path=None, in_json_path=PosixPath('examples/coco_chunk/json_file/instances_train2017_chunk3x2.json'), out_format='json_tree', out_path=PosixPath('/tmp/json_tree'), overwrite=False)
  INFO:root:Loading json file from file: examples/coco_chunk/json_file/instances_train2017_chunk3x2.json
  INFO:root:Loaded: images=6, annotations=6, categories=3
  INFO:root:Dumping json tree to dir: /tmp/json_tree
  INFO:root:[+] Success: json_tree dumped to /tmp/json_tree: ['info.json', 'info', 'categories', 'annotations', 'licenses', 'images']
  $ tree /tmp/json_tree
  /tmp/json_tree
  ├── annotations
  │   ├── 124710.json
  │   ├── 124713.json
  │   ├── 131774.json
  │   ├── 131812.json
  │   ├── 183020.json
  │   └── 183030.json
  ├── categories
  │   ├── 1.json
  │   ├── 2.json
  │   └── 3.json
  ├── images
  │   ├── 117891.json
  │   ├── 140006.json
  │   ├── 289949.json
  │   ├── 49428.json
  │   ├── 537548.json
  │   └── 71345.json
  ├── info
  ├── info.json
  └── licenses
      ├── 1.json
      ├── 2.json
      ├── 3.json
      ├── 4.json
      ├── 5.json
      ├── 6.json
      ├── 7.json
      └── 8.json
  5 directories, 24 files
  ```

  This format is used to facilitate the process of manual cleaning the CL dataset: the directory `crop` contains the list of classes named as `{sanitized-class-name}--{class-id}` so that the classes that have similar name (for example the classes of the cars `Bugatti Veyron EB 16.4` and `Bugatti Veyron 16.4 Grand Sport` will be named as `Bugatti_Veyron_EB_16_4--103209` and `Bugatti_Veyron_16_4_Grand_Sport--376319`, which makes sense since the directories are usually sorted alphabetically). The human then goes through the pictures of crops, deletes the "dirty" ones and makes sure that each class contains enough of "clean" crops. Then, we can reconstruct the dataset in the json tree representation and register it in Git.
  ```bash
  $ cocorepr \
      --in_json_file examples/coco_chunk/json_file/instances_train2017_chunk3x2.json \
      --out_path /tmp/crop_tree \
      --out_format crop_tree
  INFO:root:Arguments: Namespace(in_crop_tree_path=None, in_json_path=PosixPath('examples/coco_chunk/json_file/instances_train2017_chunk3x2.json'), indent=4, out_format='crop_tree', out_path=PosixPath('/tmp/crop_tree'), overwrite=False)
  INFO:root:Loading json file from file: examples/coco_chunk/json_file/instances_train2017_chunk3x2.json
  INFO:root:Loaded: images=6, annotations=6, categories=3
  INFO:root:Detected input dataset type: json_file: examples/coco_chunk/json_file/instances_train2017_chunk3x2.json
  INFO:root:Dumping crop tree to dir: /tmp/crop_tree
  Processing images: 100%|                                           | 6/6 [00:03<00:00,  1.60it/s]
  INFO:root:[+] Success: crop_tree dumped to /tmp/crop_tree: ['crops', 'images']
  $ tree /tmp/crop_tree
  /tmp/crop_tree
  ├── crops
  │   ├── bicycle--2
  │   │   ├── 124710.png
  │   │   └── 124713.png
  │   ├── car--3
  │   │   ├── 131774.png
  │   │   └── 131812.png
  │   └── person--1
  │       ├── 183020.png
  │       └── 183030.png
  └── images
      ├── 000000049428.jpg
      ├── 000000071345.jpg
      ├── 000000117891.jpg
      ├── 000000140006.jpg
      ├── 000000289949.jpg
      └── 000000537548.jpg
  5 directories, 12 files
  ```
  Now, this tree can be manually cleaned by a human ("dirty" crops deleted) and we'll be able to re-construct the dataset.

  Our setup:
  - Our dataset stored in git repository `/project/my-dataset` in the `json_tree` representation. This dataset suffers from incompleteness: some categories lack "clean" annotations.
  - The customer has provided us with additional data as two `json_file`s: `/inputs/annotations-new-1.json` and `/inputs/annotations-new-2.json`.
  - We would like to merge these two datasets into a `crop_tree` representation, clean it manually, and then re-construct a new dataset and save it in-place in our git repository.
  *Step 1*: merge datasets `json_tree` + `json_file`x2 -> `crop_tree`:
  ```bash
  cocorepr \
      --in_json_tree /project/my-dataset \
      --in_json_file /inputs/annotations-new-1.json /inputs/annotations-new-2.json \
      --out_path /temp/my-dataset-crops \
      --out_format crop_tree \
      --overwrite \
      --debug
  ls /temp/my-dataset-crops
  ```
  *Step 2*: manually clean the `crop_tree` in `/temp/my-dataset-crops`
  *Step 3*: re-construct the cleaned dataset:
  ```bash

  cd /project/my-dataset
  git diff-index --quiet HEAD
  cocorepr \
      --in_crop_tree /temp/my-dataset-crops \
      --in_json_tree /project/my-dataset \
      --out_path /project/my-dataset \
      --out_format json_tree \
      --overwrite \
      --debug
  ```
  Now you can commit the changes of your dataset `/project/my-dataset`.


pkgId: b9ebb3161aa08d22437bad3e354818162d27666d55fc294277726bbadd2d76ba
name: python-cocorobo-ai-tool
arch: src
version: 0.1.42
epoch: 0
release: 1
summary: CocoRobo AI Training Tools
url: http://cocorobo.cc
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocorobo-ai-tool-0.1.42-1.src.rpm
checksum_type: sha256
description:
  Pacakages:

  - scikit-image==0.16.2
  - matplotlib>=3.3.0
  - numpy>=1.19.5

  System Requirements:
  - `Nvidia CUDA` and `cuDNN` installed
  - `Ubuntu 16+` or `Windows 10+`



  To be edited.


pkgId: 57365562de03c46e5d2da632931cada372e0f858f11a2fd860e1b657598bf094
name: python-cocorum
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: An unofficial Python wrapper for the Rumble Live Stream API v1.0 (beta)
url: https://github.com/thelabcat/rumble-api-wrapper-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocorum-1.6.2-1.src.rpm
checksum_type: sha256
description:
  <h1><img src="https://raw.githubusercontent.com/thelabcat/rumble-api-wrapper-py/main/cocorum_icon.png" alt="" width="64"/> Cocorum: Rumble Live Stream API Python Wrapper</h1>

  A Python wrapper for the Rumble Live Stream API v1.0 (beta), with some quality of life additions, such as:

  - Automatic refresh when past the refresh_rate delay when querying any non_static property.
  - All timespamps are parsed to seconds since Epoch, UTC timezone.
  - Chat has new_messages and new_rants properties that return only messages and rants since the last time they were read.


  I tried to document the wrapper well, so help("cocorum") should work. Note, you are only expected to create a RumbleAPI() and / or ssechat.SSEChat() object, and work with everything through them.

  Most attributes that are not added features have the same name as the direct JSON counterparts, with the exception of adding prefixes to some things that have the same name in the JSON as Python builtin functions. For example, thing/id in JSON is thing.thing_id in this Python wrapper.

  ```
  from cocorum import RumbleAPI
  from cocorum.localvars import *
  import time


  api = RumbleAPI(API_URL, refresh_rate = 10)

  print(api.username)
  print(api.latest_follower)

  if api.latest_subscriber:
      print(api.latest_subscriber, "subscribed for $" + str(api.latest_subscriber.amount_dollars))


  livestream = api.latest_livestream #None if there is no stream running

  if livestream:
      if livestream.visibility != STREAM_VIS_PUBLIC:
          print("Stream is not public.")

      
      start_time = time.time()
      while time.time() - start_time < 60 and livestream.is_live:
          for message in livestream.chat.new_messages:
              print(message.username, "said", message)
          time.sleep(0.1)
  ```


  This part of cocorum is not part of the official Rumble Live Stream API, but may provide a more reliable method of ensuring all chat messages are received.

  ```
  from cocorum import ssechat

  chat = ssechat.SSEChat(stream_id = stream_id) #Stream ID can be base 10 or 36
  chat.clear_mailbox() #Erase messages that were still visible before we connected


  start_time = time.time()
  while time.time() - start_time < 60 and (msg := chat.get_message()):
      print(msg.user.username, "said", msg)
  ```


  Hope this helps!

  I, Wilbur Jaywright, and my brand, Marswide BGL, have no official association with Rumble Corp. beyond that of a normal user and/or channel on the Rumble Video platform. This wrapper is not officially endorsed by Rumble Corp. or its subsidiaries.

  S.D.G.


pkgId: b5db5fde9244a4c2f14e7ca702ff315af67c3998b9e2042933c08b51eef7ec75
name: python-cocorum
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: An unofficial Python wrapper for the Rumble Live Stream API v1.0 (beta)
url: https://github.com/thelabcat/rumble-api-wrapper-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocorum-2.0.0-1.src.rpm
checksum_type: sha256
description:
  <h1><img src="https://raw.githubusercontent.com/thelabcat/rumble-api-wrapper-py/main/cocorum_icon.png" alt="" width="64"/> Cocorum: Rumble Live Stream API Python Wrapper</h1>

  A Python wrapper for the Rumble Live Stream API v1.0 (beta), with some quality of life additions, such as:

  - Automatic refresh when past the refresh_rate delay when querying any non_static property.
  - All timespamps are parsed to seconds since Epoch, UTC timezone.
  - Chat has new_messages and new_rants properties that return only messages and rants since the last time they were read.


  I tried to document the wrapper well, so help("cocorum") should work. Note, you are only expected to create a RumbleAPI() and / or ssechat.SSEChat() object, and work with everything through them.

  Most attributes that are not added features have the same name as the direct JSON counterparts, with the exception of adding prefixes to some things that have the same name in the JSON as Python builtin functions. For example, thing/id in JSON is thing.thing_id in this Python wrapper.

  ```
  from cocorum import RumbleAPI
  from cocorum.localvars import *
  import time


  api = RumbleAPI(API_URL, refresh_rate = 10)

  print(api.username)
  print(api.latest_follower)

  if api.latest_subscriber:
      print(api.latest_subscriber, "subscribed for $" + str(api.latest_subscriber.amount_dollars))


  livestream = api.latest_livestream #None if there is no stream running

  if livestream:
      if livestream.visibility != STREAM_VIS_PUBLIC:
          print("Stream is not public.")

      
      start_time = time.time()
      while time.time() - start_time < 60 and livestream.is_live:
          for message in livestream.chat.new_messages:
              print(message.username, "said", message)
          time.sleep(0.1)
  ```


  This part of cocorum is not part of the official Rumble Live Stream API, but may provide a more reliable method of ensuring all chat messages are received.
  It also can do to-chat interactions, sometimes via Service.PHP.

  Example usage:
  ```
  from cocorum import chatapi


  chat = chatapi.ChatAPI(stream_id = STREAM_ID) #Stream ID can be base 10 or 36
  chat.clear_mailbox() #Erase messages that were still visible before we connected


  start_time = time.time()
  while time.time() - start_time < 60 and (msg := chat.get_message()):
      print(msg.user.username, "said", msg)
  ```


  Hope this helps!

  I, Wilbur Jaywright, and my brand, Marswide BGL, have no official association with Rumble Corp. beyond that of a normal user and/or channel on the Rumble Video platform. This wrapper is not officially endorsed by Rumble Corp. or its subsidiaries.

  S.D.G.


pkgId: cbda4fcaf3114598de3d9e69faa52c65753ae12ca1df57404f0f77133ffcc9a4
name: python-cocorum
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: An unofficial Python wrapper for the Rumble Live Stream API v1.0 (beta)
url: https://github.com/thelabcat/rumble-api-wrapper-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocorum-2.1.0-1.src.rpm
checksum_type: sha256
description:
  <h1><img src="https://raw.githubusercontent.com/thelabcat/rumble-api-wrapper-py/main/cocorum_icon.png" alt="" width="64"/> Cocorum: Rumble Live Stream API Python Wrapper</h1>

  A Python wrapper for the Rumble Live Stream API v1.0 (beta), with some quality of life additions, such as:

  - Automatic refresh when past the refresh_rate delay when querying any non_static property.
  - All timespamps are parsed to seconds since Epoch, UTC timezone.
  - Chat has new_messages and new_rants properties that return only messages and rants since the last time they were read.


  I tried to document the wrapper well, so help("cocorum") should work. Note, you are only expected to create a RumbleAPI() and / or ssechat.SSEChat() object, and work with everything through them.

  Most attributes that are not added features have the same name as the direct JSON counterparts, with the exception of adding prefixes to some things that have the same name in the JSON as Python builtin functions. For example, thing/id in JSON is thing.thing_id in this Python wrapper.

  ```
  from cocorum import RumbleAPI
  import time


  api = RumbleAPI(API_URL, refresh_rate = 10)

  print(api.username)
  print(api.latest_follower)

  if api.latest_subscriber:
      print(api.latest_subscriber, "subscribed for $" + str(api.latest_subscriber.amount_dollars))


  livestream = api.latest_livestream #None if there is no stream running

  if livestream:
      if livestream.visibility != "public":
          print("Stream is not public.")

      
      start_time = time.time()
      while time.time() - start_time < 60 and livestream.is_live:
          for message in livestream.chat.new_messages:
              print(message.username, "said", message)
          time.sleep(0.1)
  ```


  This part of cocorum is not part of the official Rumble Live Stream API, but may provide a more reliable method of ensuring all chat messages are received.
  It also can do to-chat interactions, sometimes via Service.PHP.

  Example usage:
  ```
  from cocorum import chatapi


  chat = chatapi.ChatAPI(stream_id = STREAM_ID) #Stream ID can be base 10 or 36
  chat.clear_mailbox() #Erase messages that were still visible before we connected


  start_time = time.time()
  while time.time() - start_time < 60 and (msg := chat.get_message()):
      print(msg.user.username, "said", msg)
  ```


  Hope this helps!

  I, Wilbur Jaywright, and my brand, Marswide BGL, have no official association with Rumble Corp. beyond that of a normal user and/or channel on the Rumble Video platform. This wrapper is not officially endorsed by Rumble Corp. or its subsidiaries.

  S.D.G.


pkgId: a53ee3b4f33b6ee9a41fc2854be11b98662afbfb5e0406a7fd0ef9264f02acfb
name: python-cocos
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Core Computational System
url: https://github.com/michaelnowotny/cocos
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocos-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Cocos is a package for numeric and scientific computing on GPUs for Python with a NumPy-like API.
  It supports both CUDA and OpenCL on Windows, Mac OS, and Linux.
  Internally, it relies on the ArrayFire C/C++ library.
  Cocos offers a multi-GPU map-reduce framework.
  In addition to its numeric functionality, it allows parallel computation of SymPy expressions on the GPU.



  *   Fast vectorized computation on GPUs with a NumPy-like API.
  *   Multi GPU support via map-reduce.
  *   High-performance random number generators for beta, chi-square, exponential, gamma, logistic, lognormal, normal, uniform, and Wald distributions. Antithetic random numbers for uniform and normal distributions.
  *   Provides a GPU equivalent to SymPy's lambdify, which enables numeric evaluation of symbolic SymPy (multi-dimensional array) expressions on the GPU for vectors of input parameters in parallel.
  *   Adaptation of SciPy's gaussian_kde to the GPU



  1.  [Installation](#installation)
  2.  [Getting Started](#getting-started)
  3.  [Multi-GPU Computing](#multi-gpu-computing)
  4.  [Memory Limitations on the GPU Device](#memory-limitations-on-the-gpu-device)
  5.  [Examples](#packaged-examples)
  5.1. [Estimating Pi via Monte Carlo](#estimating-pi-via-monte-carlo)
  5.2. [Option Pricing in a Stochastic Volatility Model via Monte Carlo](#option-pricing-in-a-stochastic-volatility-model-via-monte-carlo)
  5.3. [Numeric evaluation of SymPy array expressions on the GPU](#numeric-evaluation-of-sympy-array-expressions-on-the-gpu)
  5.4. [Kernel Density Estimation](#kernel-density-estimation)
  6.  [Benchmark](#benchmark)
  7.  [Functionality](#functionality)
  8.  [Limitations and Differences with NumPy](#limitations-and-differences-with-numpy)
  9.  [A Note on Hardware Configurations for Multi-GPU Computing](#a-note-on-hardware-configurations-for-multi-gpu-computing)
  10.  [License](#license)




  - Windows or Linux: [ArrayFire 3.6.4](http://arrayfire.s3.amazonaws.com/index.html#!/3.6.4%2F)
  - MacOS: [ArrayFire 3.5.1](http://arrayfire.s3.amazonaws.com/index.html#!/3.5.1%2F)


  ArrayFire's functionality is contained in dynamic libries,
  dynamic link libraries (.dll) on Windows and shared objects (.so) on Unix.

  This step is to ensure that these library files can be located on your system.
  On Windows, this can be done by adding `%AF_PATH%\lib` to the path environment variable.
  On Linux and Mac, one can either install (or copy) the ArrayFire libraries and their dependencies
  to `/usr/local/lib` or modify the environment variable `LD_LIBRARY_PATH` (Linux) or
  `DYLD_LIBRARY_PATH` (MacOS) to include the ArrayFire library directory.


  <pre>
  pip install cocos
  </pre>
  or
  <pre>
  pip3 install cocos
  </pre>
  if not using Anaconda.

  To get the latest version, clone the repository from github,
  open a terminal/command prompt, navigate to the root folder and install via
  <pre>
  pip install .
  </pre>
  or
  <pre>
  pip3 install .
  </pre>
  if not using Anaconda.



  Print available devices
  <pre>
  import cocos.device as cd
  cd.info()
  </pre>

  Select a device
  <pre>
  cd.ComputeDeviceManager.set_compute_device(0)
  </pre>


  <pre>

  import cocos.numerics as cn


  a = cn.array([[1.0, 2.0], [3.0, 4.0]])
  b = cn.array([[5.0], [6.0]])


  print(a)
  print(b)


  c = a @ b
  print(c)


  d = cn.random.randn(2, 2)
  print(d)
  </pre>


  Cocos provides `map-reduce` as well as the related `map-combine` as multi-GPU
  programming models. The computations are separated into 'batches' and then distributed
  across GPU devices in a pool. Cocos implements multi-GPU support via process-based parallelism.

  To run the function `my_gpu_function` over separate batches of input data on multiple
  GPUs in parallel, first create a `ComputeDevicePool`:
  <pre>
  compute_device_pool = cocos.multi_processing.device_pool.ComputeDevicePool()
  </pre>

  To construct the batches, separate the arguments of the function into
  *   a list of args lists and (one list per batch)
  *   a list of kwargs dictionaries (one dictionary per batch)

  <pre>
  args_list = [args_list_1, arg_list_2, ..., arg_list_n]
  kwargs_list = [kwargs_dict_1, kwargs_dict_2, ..., kwargs_dict_n]
  </pre>

  Run the function in separate batches via `map_reduce`
  <pre>
  result = \
      compute_device_pool.map_reduce(f=my_gpu_function,
                                     reduction=my_reduction_function,
                                     initial_value=...,
                                     host_to_device_transfer_function=...,
                                     device_to_host_transfer_function=...,
                                     args_list=args_list
                                     kwargs_list=kwargs_list)

  </pre>
  The reduction function iteratively aggregates two results from the list of results generated by
  `my_gpu_function` from left to right, beginning at `initial_value` (i.e. reducing
  `initial_value` and the result of `my_gpu_function` corresponding to the first batch).
  The list of results is in the same order to the list of args and kwargs.

  If the function requires input arrays on the GPU, it must be provided to `map_reduce` as
  a NumPy array. The data is then sent to the process managing the GPU assigned to this
  batch, where it is moved to the GPU device by a `host_to_device_transfer_function`.
  This function needs to be implemented by the user.

  Likewise, results that involve GPU arrays are transferred to the host via a user-supplied
  `device_to_host_transfer_function` and are then sent back to the main process before
  reduction takes place.

  `map_combine` is a variation of `map_reduce`, in which a `combination` function aggregates the
  list of results in a single step.

  Please refer to the documentation of `cocos.multi_processing.device_pool.ComputeDevicePool.map_reduce` as well as
  `cocos.multi_processing.device_pool.ComputeDevicePool.map_combine` for further details.
  See 'examples/heston_pricing_multi_gpu_example.py' for a fully worked example.


  It is common for modern standard desktop computers to support up to support up to 128GB of RAM.
  Video cards by contrast only feature a small fraction of VRAM. The consequence is that algorithms that
  work well on a CPU can experience into memory limitations when run on a GPU device.

  In some cases this problem can be resolved by running the computation in batches or chunks and transferring results
  from the GPU to the host after each batch has been processed.

  Using `map_reduce_single_device` and `map_combine_single_device` found in
  `cocos.multi_processing.single_device_batch_processing`, computations on a single GPU can be split into chunks
  and run sequentially. The interface is modeled after the multi GPU functionality described in the previous section.

  Calls to `map_reduce_single_device` and `map_combine_single_device` can  be nested in a multi GPU computation,
  which is how multi GPU evaluation of kernel density estimates is realized in Cocos
  (see `cocos.scientific.kde.gaussian_kde.evaluate_in_batches_on_multiple_gpus`).


  1.  [Estimating Pi via Monte Carlo](#estimating-pi-via-monte-carlo)
  2.  [Option Pricing in a Stochastic Volatility Model via Monte Carlo](#option-pricing-in-a-stochastic-volatility-model-via-monte-carlo)
  3.  [Numeric evaluation of SymPy array expressions on the GPU](#numeric-evaluation-of-sympy-array-expressions-on-the-gpu)
  4.  [Kernel Density Estimation](#kernel-density-estimation)



  The following code estimates Pi via Monte-Carlo simulation.
  Since Cocos offers a NumPy-like API, the same code works on the both the GPU and the CPU via NumPy.

  <pre>
  import time
  import cocos.device as cd

  def estimate_pi(n: int, gpu: bool = True) -> float:
      if gpu:
          import cocos.numerics as np
          import cocos.numerics.random as random
      else:
          import numpy as np
          import numpy.random as random

      x = np.random.rand(n)
      y = np.random.rand(n)
      in_quarter_circle = (x * x + y * y) <= 1.0
      estimate = int(np.sum(in_quarter_circle))

      return estimate / n * 4




  cd.init()


  cd.info()


  n = 100000000
  print(f'simulating {n} draws')


  pi_cpu = estimate_pi(n, gpu=False)
  print(f'Estimate of Pi on cpu: {pi_cpu}')


  pi_gpu = estimate_pi(n, gpu=True)
  print(f'Estimate of Pi on gpu: {pi_gpu}')


  R = 10


  tic = time.time()
  for r in range(R):
      pi_gpu = estimate_pi(n, gpu=True)
      cd.sync()

  time_on_gpu = time.time() - tic

  print(f'time elapsed on gpu: {time_on_gpu}')


  tic = time.time()
  for r in range(R):
      pi_cpu = estimate_pi(n, gpu=False)

  time_on_cpu = time.time() - tic

  print(f'time elapsed on cpu: {time_on_cpu}')


  print(f'speedup factor on gpu: {time_on_cpu/time_on_gpu}')
  </pre>



  In this example, we are simulating sample paths of the logarithmic price of an
  underlying security under the risk-neutral probability measure via the
  Euler–Maruyama discretization method.

  The stochastic process is Heston's classical 1992 setup of a security price
  subject to stochastic volatility. The log price and its instantanous variance
  are governed by the following system of stochastic differential equations (SDE):

  ![log price sde](https://raw.githubusercontent.com/michaelnowotny/cocos/master/images/security_price_sde.png)

  ![volatility sde](https://raw.githubusercontent.com/michaelnowotny/cocos/master/images/volatility_sde.png)

  The simulation code below demonstrates how to write code that supports both CPU
  and GPU computing. The complete code is available under examples.

  <pre>
  def simulate_heston_model(T: float,
                            N: int,
                            R: int,
                            mu: float,
                            kappa: float,
                            v_bar: float,
                            sigma_v: float,
                            rho: float,
                            x0: float,
                            v0: float,
                            gpu: bool = False) -> tp.Tuple:
      """
      This function simulates R paths from the Heston stochastic volatility model
      over a time horizon of length T divided into N steps.

      :param T: time horizon of the simulation
      :param N: number of steps
      :param R: number of paths to simulate
      :param mu: expected return
      :param kappa: mean-reversion speed of volatility
      :param v_bar: long-run mean of volatility
      :param sigma_v: volatility of volatility
      :param rho: instantaneous correlation of shocks to price and to volatility
      :param x0: initial log price
      :param v0: initial volatility
      :param gpu: whether to compute on the GPU
      :return: a tuple of two R-dimensional numeric arrays for log price and
               volatility
      """
      if gpu:
          import cocos.numerics as np
          import cocos.numerics.random as random
      else:
          import numpy as np
          import numpy.random as random

      Delta_t = T / float(N - 1)

      x = [np.full((R,), x0, dtype=numpy.float32),
           np.zeros((R,), dtype=numpy.float32)]

      v = [np.full((R,), v0, dtype=numpy.float32),
           np.zeros((R,), dtype=numpy.float32)]

      sqrt_delta_t = math.sqrt(Delta_t)
      sqrt_one_minus_rho_square = math.sqrt(1 - rho ** 2)

      
      m = np.zeros((2,), dtype=numpy.float32)
      m[0] = rho
      m[1] = sqrt_one_minus_rho_square
      zero_array = np.zeros((R,), dtype=numpy.float32)

      t_current = 0
      for t in range(1, N):
          t_previous = (t + 1) % 2
          t_current = t % 2

          
          dBt = random.randn(R, 2) * sqrt_delta_t

          sqrt_v_lag = np.sqrt(v[t_previous])
          x[t_current] = x[t_previous] \
                       + (mu - 0.5 * v[t_previous]) * Delta_t \
                       + np.multiply(sqrt_v_lag, dBt[:, 0])
          v[t_current] = v[t_previous] \
                       + kappa * (v_bar - v[t_previous]) * Delta_t \
                       + sigma_v * np.multiply(sqrt_v_lag, np.dot(dBt, m))
          v[t_current] = np.maximum(v[t_current], 0.0)

      x = x[t_current]
      v = np.maximum(v[t_current], 0.0)

      return x, v
  </pre>

  The following code computes the option price from simulated price paths of the
  underlying. It demonstrates how to dynamically choose between Cocos and NumPy
  based on the type input array. Note that in this particular setup, one would
  typically use Fourier techniques to price the option rather than Monte Carlo simulation.
  Simulation techniques can be useful when considering stochastic processes outside the
  affine framework or more generally whenever the conditional characteristic function
  of the transition density is costly to evaluate or when considering path-dependent options.

  <pre>
  def compute_option_price(r: float,
                           T: float,
                           K: float,
                           x_simulated,
                           num_pack: tp.Optional[types.ModuleType] = None):
      """
      Compute the function of a plain-vanilla call option from simulated
      log-returns.

      :param r: the risk-free rate
      :param T: the time to expiration
      :param K: the strike price
      :param x_simulated: a numeric array of simulated log prices of the underlying
      :param num_pack: a module - either numpy or cocos.numerics
      :return: option price
      """

      if not num_pack:
          use_gpu, num_pack = get_gpu_and_num_pack_by_dtype(x_simulated)

      return math.exp(-r * T) \
             * num_pack.mean(num_pack.maximum(num_pack.exp(x_simulated) - K, 0))
  </pre>



  Cocos can compile symbolic arrays defined using SymPy to GPU or CPU code.

  As an example, consider the following vector valued function.
  ![vector_valued_function](https://raw.githubusercontent.com/michaelnowotny/cocos/master/images/f_x1_x2_x3.png).
  Here g is a scalar valued function that can be specified at a later point when
  numerical evaluation is of interest.
  One reason for this setup would be to retain generality.
  Another reason might be that a symbolic representation of this function is not
  available but one has access to an algorithm (a Python function) that can compute g.


  The goal is to evaluate this function at many x = (x_1, x_2, x_3) in parallel on a GPU.

  In order to specify this function using SumPy, begin by defining symbolic arguments
  <pre>
  x1, x2, x3, t = sym.symbols('x1, x2, x3, t')
  </pre>

  Separate the state symbols 'x1', 'x2', and 'x3' from the time symbol 't' and collect them in a tuple
  <pre>
  argument_symbols = (x1, x2, x3)
  </pre>

  Declare an as of yet unspecified function g
  <pre>
  g = sym.Function('g')
  </pre>

  Define the function f
  <pre>
  f = sym.Matrix([[x1 + x2], [(g(t) * x1 + x3) ** 2], [sym.exp(x1 + x2 + g(t))]])
  </pre>

  Compute the Jacobian of g w.r.t x1, x2, and x3 symbolically
  <pre>
  jacobian_f = f.jacobian([x1, x2, x3])
  </pre>
  The Jacobian is given by
  ![jacobian_of_vector_valued_function](https://raw.githubusercontent.com/michaelnowotny/cocos/master/images/jacobian_f_x1_x2_x3.png)

  Specify the concrete form of g as g(t) = ln(t)
  <pre>
  def numeric_time_function(t: float):
      return np.log(t)
  </pre>

  Convert the symbolic array expression to an object that can evaluated numerically on the cpu or gpu
  <pre>
  jacobian_f_lambdified \
      = LambdifiedMatrixExpression(
          argument_symbols=argument_symbols,
          time_symbol=t,
          symbolic_matrix_expression=jacobian_f,
          symbolic_time_function_name_to_numeric_time_function_map={'g': numeric_time_function})
  </pre>

  Generate n = 10000000 random vectors for x1, x2, and x3 at which to evaluate the function in parallel
  <pre>
  n = 10000000
  X_gpu = cn.random.rand(n, 3)
  X_cpu = np.array(X_gpu)
  </pre>

  Numerically evaluate the Jacobian on the GPU for t=1
  <pre>
  jacobian_f_numeric_gpu = \
      (jacobian_f_lambdified
       .evaluate_with_kwargs(x1=X_gpu[:, 0],
                             x2=X_gpu[:, 1],
                             x3=X_gpu[:, 2],
                             t=1.0))
  </pre>

  Numerically evaluate the Jacobian on the CPU for t=1
  <pre>
  jacobian_f_numeric_gpu = \
      (jacobian_f_lambdified
       .evaluate_with_kwargs(x1=X_cpu[:, 0],
                             x2=X_cpu[:, 1],
                             x3=X_cpu[:, 2],
                             t=1.0))
  </pre>

  Verify that the results match
  <pre>
  print(f'numerical results from cpu and gpu match: '
        f'{np.allclose(jacobian_f_numeric_gpu, jacobian_f_numeric_cpu)}')
  </pre>


  `cocos.scientific.kde import gaussian_kde` is a replacement for SciPy's
  `scipy.stats.kde.gaussian_kde` class that works on the GPU.
  GPU support is turned on by setting `gpu=True` in its constructor.
  Evaluating a kernel density estimate from a dataset in the NumPy array `points`
  on a grid in the NumPy array `grid` works as follows:
  <pre>
  from cocos.scientific.kde import gaussian_kde
  gaussian_kde = gaussian_kde(points, gpu=True)
  density_estimate = gaussian_kde_cocos.evaluate(grid)
  </pre>

  To preserve GPU memory, the evaluation of the KDE can proceed sequentially in batches as follows
  <pre>
  density_estimate = gaussian_kde_cocos.evaluate_in_batches(grid, maximum_number_of_elements_per_batch)
  </pre>
  where the `maximum_number_of_elements_per_batch` is the maximum number of data points times
  evaluation points to process in a single batch.

  The Kernel density estimate can be computed on different points on multiple GPUs in parallel
  using the method `evaluate_in_batches_on_multiple_gpus` as follows
  <pre>
  comnpute_device_pool = ComputeDevicePool()
  gaussian_kde = gaussian_kde(points, gpu=False)
  density_estimate = \
      gaussian_kde_cocos.evaluate_in_batches_on_multiple_gpus(grid,
                                                              maximum_number_of_elements_per_batch,
                                                              comnpute_device_pool)
  </pre>
  Note that the `gpu` parameter in the `gaussian_kde` constructor must be set to `false` for multi gpu
  support and `points` must be a a NumPy array.



  This benchmark compares the runtime performance of the Monte Carlo pi example
  using NumPy on 1 through 8 cpu cores as well as 1-2 GPUs using Cocos.

  The results were produced on a machine with an Intel Core i7 9700K with 128GB of
  RAM and a NVidia GeForce GTX 1060 running Windows 10. A total of 1000000000 points
  are drawn in 20 batches.

  <table>
  <tbody>
  <tr>
  <th></th>
  <th>Total Time in Seconds</th>
  <th>Speedup Compared to NumPy</th>
  </tr>
  <tr>
  <td>Single Core NumPy</td>
  <td>17.2867612</td>
  <td>1.0</td>
  </tr>
  <tr>
  <td>NumPy with 1 CPU core(s)</td>
  <td>17.1750117</td>
  <td>1.0065065166738723</td>
  </tr>
  <tr>
  <td>NumPy with 2 CPU core(s)</td>
  <td>10.494477000000003</td>
  <td>1.6472246496895457</td>
  </tr>
  <tr>
  <td>NumPy with 3 CPU core(s)</td>
  <td>8.422800300000006</td>
  <td>2.0523769511667025</td>
  </tr>
  <tr>
  <td>NumPy with 4 CPU core(s)</td>
  <td>7.082252900000007</td>
  <td>2.440856242227665</td>
  </tr>
  <tr>
  <td>NumPy with 5 CPU core(s)</td>
  <td>6.365301000000002</td>
  <td>2.715780636296696</td>
  </tr>
  <tr>
  <td>NumPy with 6 CPU core(s)</td>
  <td>5.8881023</td>
  <td>2.935879901407284</td>
  </tr>
  <tr>
  <td>NumPy with 7 CPU core(s)</td>
  <td>5.609009299999997</td>
  <td>3.081963369181793</td>
  </tr>
  <tr>
  <td>NumPy with 8 CPU core(s)</td>
  <td>5.667201699999993</td>
  <td>3.0503169139012685</td>
  </tr>
  <tr>
  <td>Cocos Single GPU</td>
  <td>0.17866180000000043</td>
  <td>96.75689599007711</td>
  </tr>
  <tr>
  <td>Cocos with 1 GPU(s)</td>
  <td>0.1841428000000036</td>
  <td>93.87693246762655</td>
  </tr>
  <tr>
  <td>Cocos with 2 GPU(s)</td>
  <td>0.09644749999999647</td>
  <td>179.23493299464096</td>
  </tr>
  </table>

  ![benchmark_results](https://raw.githubusercontent.com/michaelnowotny/cocos/master/images/monte_carlo_pi_benchmark_results.png)

  Package versions used:
  - arrayfire: 3.6.4
  - arrayfire-python: 3.6.20181017
  - cocos: 0.1.14
  - CUDA: 9.2
  - cupy-cuda92: 6.2.0
  - NumPy: 1.16.4
  - Python: 3.7.3



  This benchmark compares the runtime performance of the option pricing example
  under a Heston stochastic volatility model on the CPU using NumPy on a single
  core as well as on all cores simultaneously and the GPU using Cocos and CuPy.
  CuPy is another package that provides a NumPy-like API for GPU computing.

  The results were produced on a machine with an Intel Core i7 9700K with 128GB of
  RAM and two NVidia GeForce GTX 1060 running Windows 10. Two Million paths are being simulated with
  500 time steps per year.

  <table>
  <tbody>
  <tr>
  <th></th>
  <th>Total Time in Seconds</th>
  <th>Speedup Compared to NumPy</th>
  </tr>
  <tr>
  <td>NumPy</td>
  <td>32.782310247421265</td>
  <td>1.0</td>
  </tr>
  <tr>
  <td>Cocos</td>
  <td>1.856126070022583</td>
  <td>17.661682994960795</td>
  </tr>
  <tr>
  <td>CuPy</td>
  <td>2.815166473388672</td>
  <td>11.64489224964396</td>
  </tr>
  <tr>
  <td>NumPy Multicore</td>
  <td>7.143897294998169</td>
  <td>4.588855199580479</td>
  </tr>
  <tr>
  <td>Cocos on 1 GPU</td>
  <td>1.8460988998413086</td>
  <td>17.757613229843344</td>
  </tr>
  <tr>
  <td>Cocos on 2 GPUs</td>
  <td>0.9753890037536621</td>
  <td>33.60947285776512</td>
  </tr>
  </table>

  ![benchmark_results](https://raw.githubusercontent.com/michaelnowotny/cocos/master/images/heston_benchmark_results.png)

  Package versions used:
  - arrayfire: 3.6.4
  - arrayfire-python: 3.6.20181017
  - cocos: 0.1.14
  - CUDA: 9.2
  - cupy-cuda92: 6.2.0
  - NumPy: 1.16.4
  - Python: 3.7.3



  Most differences between NumPy and Cocos stem from two sources:

  1.  NumPy is row-major (C style) whereas ArrayFire is column-major (Fortran style).
  2.  Only part of NumPy's functionality is present in ArrayFire, which Cocos is based on.



  <table>

  <tbody>

  <tr>

  <th>Attribute</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>T</td>

  <td>Same as self.transpose(), except that self is returned if self.ndim < 2.</td>

  <td></td>

  </tr>

  <tr>

  <td>H</td>

  <td>Conjugate transpose.</td>

  <td>attribute is not present in NumPy</td>

  </tr>

  <tr>

  <td>data</td>

  <td>Python buffer object pointing to the start of the array’s data.</td>

  <td>attribute not implemented</td>

  </tr>

  <tr>

  <td>dtype</td>

  <td>Data-type of the array’s elements.</td>

  <td></td>

  </tr>

  <tr>

  <td>flags</td>

  <td>Information about the memory layout of the array.</td>

  <td>attribute not implemented</td>

  </tr>

  <tr>

  <td>flat</td>

  <td>A 1-D iterator over the array.</td>

  <td>attribute not implemented</td>

  </tr>

  <tr>

  <td>imag</td>

  <td>The imaginary part of the array.</td>

  <td></td>

  </tr>

  <tr>

  <td>real</td>

  <td>The real part of the array.</td>

  <td></td>

  </tr>

  <tr>

  <td>size</td>

  <td>Number of elements in the array.</td>

  <td></td>

  </tr>

  <tr>

  <td>itemsize</td>

  <td>Length of one array element in bytes.</td>

  <td></td>

  </tr>

  <tr>

  <td>nbytes</td>

  <td>Total bytes consumed by the elements of the array.</td>

  <td></td>

  </tr>

  <tr>

  <td>ndim</td>

  <td>Number of array dimensions.</td>

  <td></td>

  </tr>

  <tr>

  <td>shape</td>

  <td>Tuple of array dimensions.</td>

  <td></td>

  </tr>

  <tr>

  <td>strides</td>

  <td>Tuple of bytes to step in each dimension when traversing an array.</td>

  <td></td>

  </tr>

  <tr>

  <td>ctypes</td>

  <td>An object to simplify the interaction of the array with the ctypes module.</td>

  <td>attribute not implemented</td>

  </tr>

  <tr>

  <td>base</td>

  <td>Base object if memory is from some other object.</td>

  <td>attribute not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Method</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>all(axis=None)</td>

  <td>Returns True if all elements evaluate to True.</td>

  <td>parameters "out" and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>any(axis=None)</td>

  <td>Returns True if any of the elements of a evaluate to True.</td>

  <td>parameters "out" and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>argmax(axis=None)</td>

  <td>Return indices of the maximum values along the given axis.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>argmin(axis=None)</td>

  <td>Return indices of the minimum values along the given axis of a.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>argpartition</td>

  <td>Returns the indices that would partition this array.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>argsort(axis=-1, ascending=True)</td>

  <td>Returns the indices that would sort this array.</td>

  <td>has additional parameter "ascending"; does not support parameters "kind" and "order"</td>

  </tr>

  <tr>

  <td>astype(dtype)</td>

  <td>Copy of the array, cast to a specified type.</td>

  <td>does not support parameters "order", "casting", "subok", and "copy"</td>

  </tr>

  <tr>

  <td>byteswap</td>

  <td>Swap the bytes of the array elements</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>choose</td>

  <td>Use an index array to construct a new array from a set of choices.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>clip(min, max)</td>

  <td>Return an array whose values are limited to [min, max].</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>compress</td>

  <td>Return selected slices of this array along given axis.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>conj()</td>

  <td>Complex-conjugate all elements.</td>

  <td></td>

  </tr>

  <tr>

  <td>conjugate()</td>

  <td>Return the complex conjugate, element-wise.</td>

  <td></td>

  </tr>

  <tr>

  <td>copy()</td>

  <td>Return a copy of the array.</td>

  <td></td>

  </tr>

  <tr>

  <td>cumprod</td>

  <td>Return the cumulative product of the elements along the given axis.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>cumsum(axis=-1)</td>

  <td>Return the cumulative sum of the elements along the given axis.</td>

  <td>parameters "dtype" and "out" are not supported</td>

  </tr>

  <tr>

  <td>diagonal(offset = 0)</td>

  <td>Return specified diagonals.</td>

  <td>parameters "axis1" and "axis2" are not supported</td>

  </tr>

  <tr>

  <td>dot(a, b)</td>

  <td>Dot product of two arrays.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>dump</td>

  <td>Dump a pickle of the array to the specified file.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>dumps</td>

  <td>Returns the pickle of the array as a string.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>fill(value)</td>

  <td>Fill the array with a scalar value.</td>

  <td></td>

  </tr>

  <tr>

  <td>flatten()</td>

  <td>Return a copy of the array collapsed into one dimension.</td>

  <td>parameter "order" is not supported; flattens array column by column in contrast to numpy, which operates row by row (may be changed in the future)</td>

  </tr>

  <tr>

  <td>getfield</td>

  <td>Returns a field of the given array as a certain type.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>item(*args)</td>

  <td>Copy an element of an array to a standard Python scalar and return it.</td>

  <td>implemented indirectly and therefore slow</td>

  </tr>

  <tr>

  <td>itemset(*args)</td>

  <td>Insert scalar into an array (scalar is cast to array’s dtype, if possible)</td>

  <td>implemented indirectly and therefore slow</td>

  </tr>

  <tr>

  <td>max(axis=None)</td>

  <td>Return the maximum along a given axis.</td>

  <td>parameter "out" is not supported; different criterion from numpy for complex arrays</td>

  </tr>

  <tr>

  <td>mean(axis=None)</td>

  <td>Returns the average of the array elements along given axis.</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>min(axis=None)</td>

  <td>Returns the average of the array elements along given axis.</td>

  <td>parameter "out" is not supported; different criterion from numpy for complex arrays</td>

  </tr>

  <tr>

  <td>newbyteorder</td>

  <td>Return the array with the same data viewed with a different byte order.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>nonzero</td>

  <td>Return the indices of the elements that are non-zero.</td>

  <td>does not support arrays with more than three axis</td>

  </tr>

  <tr>

  <td>partition</td>

  <td>Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>prod(axis=None)</td>

  <td>Return the product of the array elements over the given axis</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>ptp</td>

  <td>Peak to peak (maximum - minimum) value along a given axis.</td>

  <td>parameter "out" is not supported; different output from numpy for complex arrays due to differences of min and max criteria compared to numpy</td>

  </tr>

  <tr>

  <td>put</td>

  <td>Set a.flat[n] = values[n] for all n in indices.</td>

  <td>method not implemented; straightforward once the attribute "flat" has been implemented</td>

  </tr>

  <tr>

  <td>ravel</td>

  <td>Return a flattened array.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>repeat(repeats, axis=None)</td>

  <td>Repeat elements of an array.</td>

  <td>order is reversed compared to numpy (see remarks for the method flatten)</td>

  </tr>

  <tr>

  <td>reshape(shape)</td>

  <td>Returns an array containing the same data with a new shape.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>resize(newshape)</td>

  <td>Change shape and size of array in-place.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>round()</td>

  <td>Return a with each element rounded to the given number of decimals.</td>

  <td>parameters "decimals" and "out" are not supported</td>

  </tr>

  <tr>

  <td>searchsorted</td>

  <td>Find indices where elements of v should be inserted in a to maintain order.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>setfield</td>

  <td>Put a value into a specified place in a field defined by a data-type.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>setflags</td>

  <td>Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>sort(axis=-1, ascending=True)</td>

  <td>Sort an array, in-place.</td>

  <td>has additional parameter "ascending"; parameters "kind" and "order" are not supported</td>

  </tr>

  <tr>

  <td>squeeze(axis=None)</td>

  <td>Remove single-dimensional entries from the shape of a.</td>

  <td></td>

  </tr>

  <tr>

  <td>std(axis=None)</td>

  <td>Returns the standard deviation of the array elements along given axis.</td>

  <td>parameters "dtype", "out", "ddof", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>sum(axis=None)</td>

  <td>Return the sum of the array elements over the given axis.</td>

  <td>parameters "dtype", "out, and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>swapaxes</td>

  <td>Return a view of the array with axis1 and axis2 interchanged.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>take</td>

  <td>Return an array formed from the elements of a at the given indices.</td>

  <td>method not implemented</td>

  </tr>

  <tr>

  <td>tobytes</td>

  <td>Construct Python bytes containing the raw data bytes in the array.</td>

  <td>method not implemented; could be implemented by first converting to numpy array for instance</td>

  </tr>

  <tr>

  <td>tofile</td>

  <td>Write array to a file as text or binary (default).</td>

  <td>method not implemented; could be implemented by first converting to numpy array for instance</td>

  </tr>

  <tr>

  <td>tolist</td>

  <td>Return the array as a (possibly nested) list.</td>

  <td>method not implemented; could be implemented by first converting to numpy array for instance</td>

  </tr>

  <tr>

  <td>tostring</td>

  <td>Construct Python bytes containing the raw data bytes in the array.</td>

  <td>method not implemented; could be implemented by first converting to numpy array for instance</td>

  </tr>

  <tr>

  <td>trace(offset=0)</td>

  <td>Return the sum along diagonals of the array.</td>

  <td>parameters "axis1", "axis2", "dtype", and "out" are not supported</td>

  </tr>

  <tr>

  <td>transpose()</td>

  <td>Returns a new array with axes transposed.</td>

  <td>parameter "*axis" is not supported; look into arrayfire function "moddims" to support *axis; new array is not a view on the old data</td>

  </tr>

  <tr>

  <td>var(axis=None, ddof=0)</td>

  <td>Returns the variance of the array elements, along given axis.</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>view</td>

  <td>New view of array with the same data.</td>

  <td>method not implemented</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>amin</td>

  <td>Return the minimum of an array or minimum along an axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>amax</td>

  <td>Return the maximum of an array or maximum along an axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nanmin</td>

  <td>Return minimum of an array or minimum along an axis, ignoring any NaNs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nanmax</td>

  <td>Return the maximum of an array or maximum along an axis, ignoring any NaNs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ptp(a, axis=None)</td>

  <td>Range of values (maximum - minimum) along an axis.</td>

  <td>parameter "out" not supported</td>

  </tr>

  <tr>

  <td>percentile</td>

  <td>Compute the qth percentile of the data along the specified axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nanpercentile</td>

  <td>Compute the qth percentile of the data along the specified axis, while ignoring nan values.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>median</td>

  <td>Compute the median along the specified axis.</td>

  <td>parameters "out", "overwrite_input"=False, and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>average(a, axis=None, weights=None)</td>

  <td>Compute the weighted average along the specified axis.</td>

  <td>parameter "returned" is not supported; does not work on Mac OS X with AMD chip when weights are given</td>

  </tr>

  <tr>

  <td>mean(a, axis=None)</td>

  <td></td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>std(a, axis=None, ddof=0)</td>

  <td>Compute the arithmetic mean along the specified axis.</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>var(a, axis=None, ddof=0)</td>

  <td>Compute the variance along the specified axis.</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>nanmedian</td>

  <td>Compute the median along the specified axis, while ignoring NaNs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nanmean</td>

  <td>Compute the arithmetic mean along the specified axis, ignoring NaNs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nanstd</td>

  <td>Compute the standard deviation along the specified axis, while ignoring NaNs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nanvar</td>

  <td>Compute the variance along the specified axis, while ignoring NaNs.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>corrcoeff(x, bias=False, ddof=None</td>

  <td>Return Pearson product-moment correlation coefficients.</td>

  <td>parameters "y" and "rowvar" are not supported</td>

  </tr>

  <tr>

  <td>correlate</td>

  <td>Cross-correlation of two 1-dimensional sequences.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>cov(m, bias=False, ddof=None)</td>

  <td>Estimate a covariance matrix, given data and weights.</td>

  <td>parameters "y", "rowvar", "fweights", and "aweights" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>histogram</td>

  <td>Compute the histogram of a set of data.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>histogram2d</td>

  <td>Compute the bi-dimensional histogram of two data samples.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>histogramdd</td>

  <td>Compute the multidimensional histogram of some data.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>bincount</td>

  <td>Count number of occurrences of each value in array of non-negative ints.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>digitize</td>

  <td>Return the indices of the bins to which each value in input array belongs.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>empty</td>

  <td>Return a new array of given shape and type, initializing entries to zero.</td>

  <td>in contrast to numpy it initializes entries to zero just like zeros</td>

  </tr>

  <tr>

  <td>empty_like</td>

  <td>Return a new array with the same shape and type as a given array.</td>

  <td>in contrast to numpy it initializes entries to zero just like zeros</td>

  </tr>

  <tr>

  <td>eye(N, M=None, k=0, dtype=np.float32)</td>

  <td>Return a 2-D array with ones on the diagonal and zeros elsewhere.</td>

  <td></td>

  </tr>

  <tr>

  <td>identity(n, dtype=np.float32)</td>

  <td>Return the identity array.</td>

  <td></td>

  </tr>

  <tr>

  <td>[ones(shape, dtype=np.float32)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones)</td>

  <td>Return a new array of given shape and type, filled with ones.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>[ones_like(a, dtype=None)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones_like)</td>

  <td>Return an array of ones with the same shape and type as a given array.</td>

  <td>parameters "order" and "subok" are not supported</td>

  </tr>

  <tr>

  <td>[zeros(shape, dtype=n.float32)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.zeros)</td>

  <td>Return a new array of given shape and type, filled with zeros.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>[zeros_like(a, dtype=None)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.zeros_like)</td>

  <td>Return an array of zeros with the same shape and type as a given array.</td>

  <td>parameters "order" and "subok" are not supported</td>

  </tr>

  <tr>

  <td>[full(shape, fill_value, dtype=n.float32)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.full)</td>

  <td>Return a new array of given shape and type, filled with fill_value.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>[full_like(a, fill_value, dtype=None)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.full_like)</td>

  <td>Return a full array with the same shape and type as a given array.</td>

  <td>parameters "order" and "subok" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>array(object, dtype=None)</td>

  <td>Create an array.</td>

  <td>parameters "copy", "order", "subok", and "ndmin" are not supported</td>

  </tr>

  <tr>

  <td>asarray</td>

  <td>Convert the input to an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asanyarray</td>

  <td>Convert the input to an ndarray, but pass ndarray subclasses through.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ascontiguousarray</td>

  <td>Return a contiguous array in memory (C order).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asmatrix</td>

  <td>Interpret the input as a matrix.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>copy(a)</td>

  <td>Return an array copy of the given object.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>frombuffer</td>

  <td>Interpret a buffer as a 1-dimensional array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fromfile</td>

  <td>Construct an array from data in a text or binary file.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fromfunction</td>

  <td>Construct an array by executing a function over each coordinate.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fromiter</td>

  <td>Create a new 1-dimensional array from an iterable object.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fromstring</td>

  <td>A new 1-D array initialized from raw binary or text data in a string.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>loadtxt</td>

  <td>Load data from a text file.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>diag(v, k=0)</td>

  <td>Extract a diagonal or construct a diagonal array.</td>

  <td></td>

  </tr>

  <tr>

  <td>diagflat(v, k=0)</td>

  <td>Create a two-dimensional array with the flattened input as a diagonal.</td>

  <td></td>

  </tr>

  <tr>

  <td>tri</td>

  <td>An array with ones at and below the given diagonal and zeros elsewhere.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>tril(m)</td>

  <td>Lower triangle of an array.</td>

  <td>parameter "k" is not supported</td>

  </tr>

  <tr>

  <td>triu(m)</td>

  <td>Upper triangle of an array.</td>

  <td>parameter "k" is not supported</td>

  </tr>

  <tr>

  <td>vander</td>

  <td>Generate a Vandermonde matrix.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>copyto</td>

  <td>Copies values from one array to another, broadcasting as necessary.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>Function</th>

  <th>Description</th>

  <th>Notes</th>

  </tr>

  <tr>

  <td>reshape(a, newshape)</td>

  <td>Gives a new shape to an array without changing its data.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>ravel</td>

  <td>Return a contiguous flattened array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ndarray.flat</td>

  <td>A 1-D iterator over the array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ndarray.flatten</td>

  <td>Return a copy of the array collapsed into one dimension.</td>

  <td>parameter "order" is not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>moveaxis</td>

  <td>Move axes of an array to new positions.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>rollaxis(a, axis[, start])</td>

  <td>Roll the specified axis backwards, until it lies in a given position.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>swapaxes(a, axis1, axis2)</td>

  <td>Interchange two axes of an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ndarray.T</td>

  <td>Same as self.transpose(), except that self is returned if self.ndim < 2.</td>

  <td></td>

  </tr>

  <tr>

  <td>transpose(a)</td>

  <td>Permute the dimensions of an array.</td>

  <td>parameter "axes" is not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>atleast_1d(*arys)</td>

  <td>Convert inputs to arrays with at least one dimension.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>atleast_2d(*arys)</td>

  <td>View inputs as arrays with at least two dimensions.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>atleast_3d(*arys)</td>

  <td>View inputs as arrays with at least three dimensions.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>broadcast</td>

  <td>Produce an object that mimics broadcasting.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>broadcast_to(array, shape[, subok])</td>

  <td>Broadcast an array to a new shape.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>broadcast_arrays(*args, **kwargs)</td>

  <td>Broadcast any number of arrays against each other.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>expand_dims(a, axis)</td>

  <td>Expand the shape of an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>[squeeze(a, axis=None)](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.squeeze.html)</td>

  <td>Remove single-dimensional entries from the shape of an array.</td>

  <td></td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>asarray(a[, dtype, order])</td>

  <td>Convert the input to an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asanyarray(a[, dtype, order])</td>

  <td>Convert the input to an ndarray, but pass ndarray subclasses through.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asmatrix(data[, dtype])</td>

  <td>Interpret the input as a matrix.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asfarray(a[, dtype])</td>

  <td>Return an array converted to a float type.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asfortranarray(a[, dtype])</td>

  <td>Return an array laid out in Fortran order in memory.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ascontiguousarray(a[, dtype])</td>

  <td>Return a contiguous array in memory (C order).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asarray_chkfinite(a[, dtype, order])</td>

  <td>Convert the input to an array, checking for NaNs or Infs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>asscalar(a)</td>

  <td>Convert an array of size 1 to its scalar equivalent.</td>

  <td></td>

  </tr>

  <tr>

  <td>require(a[, dtype, requirements])</td>

  <td>Return an ndarray of the provided type that satisfies requirements.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>concatenate((a1, a2, ...), axis=0)</td>

  <td>Join a sequence of arrays along an existing axis.</td>

  <td></td>

  </tr>

  <tr>

  <td>stack(arrays[, axis])</td>

  <td>Join a sequence of arrays along a new axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>column_stack(tup)</td>

  <td>Stack 1-D arrays as columns into a 2-D array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>dstack(tup)</td>

  <td>Stack arrays in sequence depth wise (along third axis).</td>

  <td></td>

  </tr>

  <tr>

  <td>hstack(tup)</td>

  <td>Stack arrays in sequence horizontally (along second axis).</td>

  <td></td>

  </tr>

  <tr>

  <td>vstack(tup)</td>

  <td>Stack arrays in sequence vertically (along first axis).</td>

  <td></td>

  </tr>

  <tr>

  <td>block(arrays)</td>

  <td>Assemble an nd-array from nested lists of blocks.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>split(ary, indices_or_sections[, axis])</td>

  <td>Split an array into multiple sub-arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>array_split(ary, indices_or_sections[, axis])</td>

  <td>Split an array into multiple sub-arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>dsplit(ary, indices_or_sections)</td>

  <td>Split array into multiple sub-arrays along the 3rd axis (depth).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>hsplit(ary, indices_or_sections)</td>

  <td>Split an array into multiple sub-arrays horizontally (column-wise).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>vsplit(ary, indices_or_sections)</td>

  <td>Split an array into multiple sub-arrays vertically (row-wise).</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>tile(A, reps)</td>

  <td>Construct an array by repeating A the number of times given by reps.</td>

  <td></td>

  </tr>

  <tr>

  <td>repeat(a, repeats[, axis])</td>

  <td>Repeat elements of an array.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>delete(arr, obj[, axis])</td>

  <td>Return a new array with sub-arrays along an axis deleted.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>insert(arr, obj, values[, axis])</td>

  <td>Insert values along the given axis before the given indices.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>append(arr, values[, axis])</td>

  <td>Append values to the end of an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>resize(a, new_shape)</td>

  <td>Return a new array with the specified shape.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>trim_zeros(filt[, trim])</td>

  <td>Trim the leading and/or trailing zeros from a 1-D array or sequence.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>unique(ar[, return_index, return_inverse, ...])</td>

  <td>Find the unique elements of an array.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>flip(m, axis)</td>

  <td>Reverse the order of elements in an array along the given axis.</td>

  <td></td>

  </tr>

  <tr>

  <td>fliplr(m)</td>

  <td>Flip array in the left/right direction.</td>

  <td></td>

  </tr>

  <tr>

  <td>flipud(m)</td>

  <td>Flip array in the up/down direction.</td>

  <td></td>

  </tr>

  <tr>

  <td>reshape(a, newshape)</td>

  <td>Gives a new shape to an array without changing its data.</td>

  <td>parameter "order" is not supported</td>

  </tr>

  <tr>

  <td>roll(a, shift, axis=None)</td>

  <td>Roll array elements along a given axis.</td>

  <td></td>

  </tr>

  <tr>

  <td>rot90(m[, k, axes])</td>

  <td>Rotate an array by 90 degrees in the plane specified by axes.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>bitwise_and(x1, x2)</td>

  <td>Compute the bit-wise AND of two arrays element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>bitwise_or(x1, x2)</td>

  <td>Compute the bit-wise OR of two arrays element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>bitwise_xor(x1, x2)</td>

  <td>Compute the bit-wise XOR of two arrays element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>invert(x)</td>

  <td>Compute bit-wise inversion, or bit-wise NOT, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>left_shift(x1, x2)</td>

  <td>Shift the bits of an integer to the left.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>right_shift(x1, x2)</td>

  <td>Shift the bits of an integer to the right.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  </tbody>

  </table>









  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>take(a, indices[, axis, out, mode])</td>

  <td>Take elements from an array along an axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>choose(a, choices[, out, mode])</td>

  <td>Construct an array from an index array and a set of arrays to choose from.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>compress(condition, a[, axis, out])</td>

  <td>Return selected slices of an array along given axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>diag(v, k=0)</td>

  <td>Extract a diagonal or construct a diagonal array.</td>

  <td></td>

  </tr>

  <tr>

  <td>diagonal(a[, offset, axis1, axis2])</td>

  <td>Return specified diagonals.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>select(condlist, choicelist[, default])</td>

  <td>Return an array drawn from elements in choicelist, depending on conditions.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>lib.stride_tricks.as_strided(x[, shape, ...])</td>

  <td>Create a view into the array with the given shape and strides.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>place(arr, mask, vals)</td>

  <td>Change elements of an array based on conditional and input values.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>put(a, ind, v[, mode])</td>

  <td>Replaces specified elements of an array with given values.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>putmask(a, mask, values)</td>

  <td>Changes elements of an array based on conditional and input values.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fill_diagonal(a, val[, wrap])</td>

  <td>Fill the main diagonal of the given array of any dimensionality.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>nditer</td>

  <td>Efficient multi-dimensional iterator object to iterate over arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ndenumerate(arr)</td>

  <td>Multidimensional index iterator.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ndindex(*shape)</td>

  <td>An N-dimensional iterator object to index arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>flatiter</td>

  <td>Flat iterator object to iterate over arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>lib.Arrayterator(var[, buf_size])</td>

  <td>Buffered iterator for big arrays.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>dot(a, b)</td>

  <td>Dot product of two arrays.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>linalg.multi_dot(arrays)</td>

  <td>Compute the dot product of two or more arrays in a single function call, while automatically selecting the fastest evaluation order.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>vdot(a, b)</td>

  <td>Return the dot product of two vectors.</td>

  <td></td>

  </tr>

  <tr>

  <td>inner(a, b)</td>

  <td>Inner product of two arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>outer(a, b)</td>

  <td>Outer product of two arrays.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>matmul(a, b[, out])</td>

  <td>Matrix product of two arrays.</td>

  <td>only handles 2d arrays</td>

  </tr>

  <tr>

  <td>tensordot(a, b[, axes])</td>

  <td>Compute tensor dot product along specified axes for arrays >= 1-D.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>einsum(subscripts, *operands[, out, dtype, ...])</td>

  <td>Evaluates the Einstein summation convention on the operands.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.matrix_power(M, n)</td>

  <td>Raise a square matrix to the (integer) power n.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>kron(a, b)</td>

  <td>Kronecker product of two arrays.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>linalg.cholesky(a)</td>

  <td>Cholesky decomposition.</td>

  <td></td>

  </tr>

  <tr>

  <td>linalg.qr(a)</td>

  <td>Compute the qr factorization of a matrix.</td>

  <td>parameter "mode" is not supported</td>

  </tr>

  <tr>

  <td>linalg.svd(a[, full_matrices, compute_uv])</td>

  <td>Singular Value Decomposition.</td>

  <td></td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>linalg.eig(a)</td>

  <td>Compute the eigenvalues and right eigenvectors of a square array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.eigh(a[, UPLO])</td>

  <td>Return the eigenvalues and eigenvectors of a Hermitian or symmetric matrix.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.eigvals(a)</td>

  <td>Compute the eigenvalues of a general matrix.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.eigvalsh(a[, UPLO])</td>

  <td>Compute the eigenvalues of a Hermitian or real symmetric matrix.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>linalg.norm(x[, ord, axis, keepdims])</td>

  <td>Matrix or vector norm.</td>

  <td>parameter "keepdims" is not supported</td>

  </tr>

  <tr>

  <td>linalg.cond(x[, p])</td>

  <td>Compute the condition number of a matrix.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.det(a)</td>

  <td>Compute the determinant of an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.matrix_rank(M, tol=None)</td>

  <td>Return matrix rank of array using SVD method</td>

  <td></td>

  </tr>

  <tr>

  <td>linalg.slogdet(a)</td>

  <td>Compute the sign and (natural) logarithm of the determinant of an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>trace(a, offset=0)</td>

  <td>Return the sum along diagonals of the array.</td>

  <td>parameters "axis1", "axis2", "dtype", and "out" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>linalg.solve(a, b)</td>

  <td>Solve a linear matrix equation, or system of linear scalar equations.</td>

  <td>additional parameter "trans" indicating whether the argument should be transposed</td>

  </tr>

  <tr>

  <td>linalg.tensorsolve(a, b[, axes])</td>

  <td>Solve the tensor equation a x = b for x.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.lstsq(a, b[, rcond])</td>

  <td>Return the least-squares solution to a linear matrix equation.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.inv(a)</td>

  <td>Compute the (multiplicative) inverse of a matrix.</td>

  <td></td>

  </tr>

  <tr>

  <td>linalg.pinv(a[, rcond])</td>

  <td>Compute the (Moore-Penrose) pseudo-inverse of a matrix.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>linalg.tensorinv(a[, ind])</td>

  <td>Compute the ‘inverse’ of an N-dimensional array.</td>

  <td></td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>all(a, axis=None)</td>

  <td>Test whether all array elements along a given axis evaluate to True.</td>

  <td>parameters "out" and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>any(a, axis=None)</td>

  <td>Test whether any array element along a given axis evaluates to True.</td>

  <td>parameters "out" and "keepdims" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>isfinite(x)</td>

  <td>Test element-wise for finiteness (not infinity or not Not a Number).</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>isinf(x)</td>

  <td>Test element-wise for positive or negative infinity.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>isnan(x)</td>

  <td>Test element-wise for NaN and return result as a boolean array.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", and "extobj" are not supported</td>

  </tr>

  <tr>

  <td>isneginf(x)</td>

  <td>Test element-wise for negative infinity, return result as bool array.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>isposinf(x)</td>

  <td>Test element-wise for positive infinity, return result as bool array.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>iscomplex(x)</td>

  <td>Returns a bool array, where True if input element is complex.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>iscomplexobj(x)</td>

  <td>Check for a complex type or an array of complex numbers.</td>

  <td></td>

  </tr>

  <tr>

  <td>isfortran(a)</td>

  <td>Returns True if the array is Fortran contiguous but not C contiguous.</td>

  <td></td>

  </tr>

  <tr>

  <td>isreal(x)</td>

  <td>Returns a bool array, where True if input element is real.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>isrealobj(x)</td>

  <td>Return True if x is a not complex type or an array of complex numbers.</td>

  <td></td>

  </tr>

  <tr>

  <td>isscalar(num)</td>

  <td>Returns True if the type of num is a scalar type.</td>

  <td></td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>logical_and(x1, x2)</td>

  <td>Compute the truth value of x1 AND x2 element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>logical_or(x1, x2)</td>

  <td>Compute the truth value of x1 OR x2 element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>logical_not(x)</td>

  <td>Compute the truth value of NOT x element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>logical_xor(x1, x2)</td>

  <td>Compute the truth value of x1 XOR x2 element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>allclose(a, b[, rtol, atol, equal_nan])</td>

  <td>Returns True if two arrays are element-wise equal within a tolerance.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>isclose(a, b[, rtol, atol, equal_nan])</td>

  <td>Returns a boolean array where two arrays are element-wise equal within a tolerance.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>array_equal(a1, a2)</td>

  <td>True if two arrays have the same shape and elements, False otherwise.</td>

  <td></td>

  </tr>

  <tr>

  <td>array_equiv(a1, a2)</td>

  <td>Returns True if input arrays are shape consistent and all elements equal.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>greater(x1, x2)</td>

  <td>Return the truth value of (x1 > x2) element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>greater_equal(x1, x2)</td>

  <td>Return the truth value of (x1 >= x2) element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>less(x1, x2)</td>

  <td>Return the truth value of (x1 < x2) element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>less_equal(x1, x2)</td>

  <td>Return the truth value of (x1 =< x2) element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>equal(x1, x2)</td>

  <td>Return (x1 == x2) element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>not_equal(x1, x2)</td>

  <td>Return (x1 != x2) element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>sin(x)</td>

  <td>Trigonometric sine, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>cos(x)</td>

  <td>Cosine element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>tan(x)</td>

  <td>Compute tangent element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arcsin(x)</td>

  <td>Inverse sine, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arccos(x)</td>

  <td>Trigonometric inverse cosine, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arctan(x)</td>

  <td>Trigonometric inverse tangent, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>hypot(x1, x2)</td>

  <td>Given the “legs” of a right triangle, return its hypotenuse.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arctan2(x1, x2)</td>

  <td>Element-wise arc tangent of x1/x2 choosing the quadrant correctly.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>degrees(x, /[, out, where, casting, order, ...])</td>

  <td>Convert angles from radians to degrees.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>radians(x, /[, out, where, casting, order, ...])</td>

  <td>Convert angles from degrees to radians.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>unwrap(p[, discont, axis])</td>

  <td>Unwrap by changing deltas between values to 2*pi complement.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>deg2rad(x, /[, out, where, casting, order, ...])</td>

  <td>Convert angles from degrees to radians.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>rad2deg(x, /[, out, where, casting, order, ...])</td>

  <td>Convert angles from radians to degrees.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>sinh(x)</td>

  <td>Hyperbolic sine, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>cosh(x)</td>

  <td>Hyperbolic cosine, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>tanh(x)</td>

  <td>Compute hyperbolic tangent element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arcsinh(x)</td>

  <td>Inverse hyperbolic sine element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arccosh(x)</td>

  <td>Inverse hyperbolic cosine, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>arctanh(x)</td>

  <td>Inverse hyperbolic tangent element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>around(a[, decimals, out])</td>

  <td>Evenly round to the given number of decimals.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>round_(a[, decimals, out])</td>

  <td>Evenly round to the given number of decimals.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>rint(x, /[, out, where, casting, order, ...])</td>

  <td>Round elements of the array to the nearest integer.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fix(x[, out])</td>

  <td>Round to nearest integer towards zero.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>floor(x)</td>

  <td>Return the floor of the input, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>ceil(x)</td>

  <td>Return the ceiling of the input, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>trunc(x)</td>

  <td>Return the truncated value of the input, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>prod(a, axis=None)</td>

  <td>Return the product of array elements over a given axis.</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>sum(a, axis=None)</td>

  <td>Sum of array elements over a given axis.</td>

  <td>parameters "dtype", "out", and "keepdims" are not supported</td>

  </tr>

  <tr>

  <td>nanprod(a[, axis, dtype, out, keepdims])</td>

  <td>Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nansum(a[, axis, dtype, out, keepdims])</td>

  <td>Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>cumprod(a[, axis, dtype, out])</td>

  <td>Return the cumulative product of elements along a given axis.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>cumsum(a, axis=None)</td>

  <td>Return the cumulative sum of the elements along a given axis.</td>

  <td>parameters "dtype" and "out" are not supported</td>

  </tr>

  <tr>

  <td>nancumprod(a[, axis, dtype, out])</td>

  <td>Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nancumsum(a[, axis, dtype, out])</td>

  <td>Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>diff(a, n=1, axis=-1)</td>

  <td>Calculate the n-th discrete difference along given axis.</td>

  <td></td>

  </tr>

  <tr>

  <td>ediff1d(ary[, to_end, to_begin])</td>

  <td>The differences between consecutive elements of an array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>gradient(f, *varargs, **kwargs)</td>

  <td>Return the gradient of an N-dimensional array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>cross(a, b[, axisa, axisb, axisc, axis])</td>

  <td>Return the cross product of two (arrays of) vectors.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>trapz(y[, x, dx, axis])</td>

  <td>Integrate along the given axis using the composite trapezoidal rule.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>exp(x)</td>

  <td>Calculate the exponential of all elements in the input array.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>expm1(x)</td>

  <td>Calculate exp(x) - 1 for all elements in the array.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>exp2(x)</td>

  <td>Calculate 2**p for all p in the input array.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>log(x)</td>

  <td>Natural logarithm, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>log10(x)</td>

  <td>Return the base 10 logarithm of the input array, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>log2(x)</td>

  <td>Base-2 logarithm of x.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>log1p(x)</td>

  <td>Return the natural logarithm of one plus the input array, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>logaddexp(x1, x2, /[, out, where, casting, ...])</td>

  <td>Logarithm of the sum of exponentiations of the inputs.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>logaddexp2(x1, x2, /[, out, where, casting, ...])</td>

  <td>Logarithm of the sum of exponentiations of the inputs in base-2.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>i0(x)</td>

  <td>Modified Bessel function of the first kind, order 0.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>sinc(x)</td>

  <td>Return the sinc function.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>signbit(x, /[, out, where, casting, order, ...])</td>

  <td>Returns element-wise True where signbit is set (less than zero).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>copysign(x1, x2, /[, out, where, casting, ...])</td>

  <td>Change the sign of x1 to that of x2, element-wise.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>frexp(x[, out1, out2], / [[, out, where, ...])</td>

  <td>Decompose the elements of x into mantissa and twos exponent.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ldexp(x1, x2, /[, out, where, casting, ...])</td>

  <td>Returns x1 * 2**x2, element-wise.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nextafter(x1, x2, /[, out, where, casting, ...])</td>

  <td>Return the next floating-point value after x1 towards x2, element-wise.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>spacing(x, /[, out, where, casting, order, ...])</td>

  <td>Return the distance between x and the nearest adjacent number.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>add(x1, x2)</td>

  <td>Add arguments element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>reciprocal(x)</td>

  <td>Return the reciprocal of the argument, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>negative(x)</td>

  <td>Numerical negative, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>multiply(x1, x2)</td>

  <td>Multiply arguments element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>divide(x1, x2)</td>

  <td>Divide arguments element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>power(x1, x2)</td>

  <td>First array elements raised to powers from second array, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>subtract(x1, x2)</td>

  <td>Subtract arguments, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>true_divide(x1, x2)</td>

  <td>Returns a true division of the inputs, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>floor_divide(x1, x2)</td>

  <td>Return the largest integer smaller or equal to the division of the inputs.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>float_power(x1, x2, /[, out, where, ...])</td>

  <td>First array elements raised to powers from second array, element-wise.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fmod(x1, x2, /[, out, where, casting, ...])</td>

  <td>Return the element-wise remainder of division.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>mod(x1, x2)</td>

  <td>Return the element-wise remainder of division.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>modf(x[, out1, out2], / [[, out, where, ...])</td>

  <td>Return the fractional and integral parts of an array, element-wise.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>remainder(x1, x2)</td>

  <td>Return element-wise remainder of division.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>divmod(x1, x2[, out1, out2], / [[, out, ...])</td>

  <td>Return element-wise quotient and remainder simultaneously.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>angle(z)</td>

  <td>Return the angle of the complex argument.</td>

  <td>parameter "deg" is not supported</td>

  </tr>

  <tr>

  <td>real(val)</td>

  <td>Return the real part of the complex argument.</td>

  <td></td>

  </tr>

  <tr>

  <td>imag(val)</td>

  <td>Return the imaginary part of the complex argument.</td>

  <td></td>

  </tr>

  <tr>

  <td>conj(x)</td>

  <td>Return the complex conjugate, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>convolve(a, v[, mode])</td>

  <td>Returns the discrete, linear convolution of two one-dimensional sequences.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>convolve(a, v[, mode])</td>

  <td>Returns the discrete, linear convolution of two one-dimensional sequences.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>clip(a, a_min, a_max)</td>

  <td>Clip (limit) the values in an array.</td>

  <td>parameter "out" is not supported</td>

  </tr>

  <tr>

  <td>sqrt(x)</td>

  <td>Return the positive square-root of an array, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>cbrt(x)</td>

  <td>Return the cube-root of an array, element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>square(x)</td>

  <td>Return the element-wise square of the input.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>absolute(x)</td>

  <td>Calculate the absolute value element-wise.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>fabs(x, /[, out, where, casting, order, ...])</td>

  <td>Compute the absolute values element-wise.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>sign(x)</td>

  <td>Returns an element-wise indication of the sign of a number.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>heaviside(x1, x2, /[, out, where, casting, ...])</td>

  <td>Compute the Heaviside step function.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>maximum(x1, x2)</td>

  <td>Element-wise maximum of array elements.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>minimum(x1, x2)</td>

  <td>Element-wise minimum of array elements.</td>

  <td>parameters "out", "where", "casting", "order", "dtype", "subok", "signature", "extobj" are not supported</td>

  </tr>

  <tr>

  <td>fmax(x1, x2, /[, out, where, casting, ...])</td>

  <td>Element-wise maximum of array elements.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>fmin(x1, x2, /[, out, where, casting, ...])</td>

  <td>Element-wise minimum of array elements.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>nan_to_num(x[, copy])</td>

  <td>Replace nan with zero and inf with finite numbers.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>real_if_close(a[, tol])</td>

  <td>If complex input returns a real array if complex parts are close to zero.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>interp(x, xp, fp[, left, right, period])</td>

  <td>One-dimensional linear interpolation.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>





  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>rand(d0, d1, ..., dn)</td>

  <td>Random values in a given shape.</td>

  <td></td>

  </tr>

  <tr>

  <td>randn(d0, d1, ..., dn)</td>

  <td>Return a sample (or samples) from the “standard normal” distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>randint(low[, high, size, dtype])</td>

  <td>Return random integers from low (inclusive) to high (exclusive).</td>

  <td></td>

  </tr>

  <tr>

  <td>random_integers(low[, high, size])</td>

  <td>Random integers of type np.int between low and high, inclusive.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>random_sample([size])</td>

  <td>Return random floats in the half-open interval [0.0, 1.0).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>random([size])</td>

  <td>Return random floats in the half-open interval [0.0, 1.0).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>ranf([size])</td>

  <td>Return random floats in the half-open interval [0.0, 1.0).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>sample([size])</td>

  <td>Return random floats in the half-open interval [0.0, 1.0).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>choice(a[, size, replace, p])</td>

  <td>Generates a random sample from a given 1-D array</td>

  <td>replace=False and p != None are not supported</td>

  </tr>

  <tr>

  <td>bytes(length)</td>

  <td>Return random bytes.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>shuffle(x)</td>

  <td>Modify a sequence in-place by shuffling its contents.</td>

  <td></td>

  </tr>

  <tr>

  <td>permutation(x)</td>

  <td>Randomly permute a sequence, or return a permuted range.</td>

  <td></td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>beta(a, b, size=None)</td>

  <td>Draw samples from a Beta distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>binomial(n, p[, size])</td>

  <td>Draw samples from a binomial distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>chisquare(df, size=None)</td>

  <td>Draw samples from a chi-square distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>dirichlet(alpha[, size])</td>

  <td>Draw samples from the Dirichlet distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>exponential(scale=1.0, size=None)</td>

  <td>Draw samples from an exponential distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>f(dfnum, dfden[, size])</td>

  <td>Draw samples from an F distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>gamma(shape, scale=1.0, size=None)</td>

  <td>Draw samples from a Gamma distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>geometric(p[, size])</td>

  <td>Draw samples from the geometric distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>gumbel([loc, scale, size])</td>

  <td>Draw samples from a Gumbel distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>hypergeometric(ngood, nbad, nsample[, size])</td>

  <td>Draw samples from a Hypergeometric distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>laplace([loc, scale, size])</td>

  <td>Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay).</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>logistic(loc=0.0, scale=1.0, size=None)</td>

  <td>Draw samples from a logistic distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>lognormal(mean=0.0, sigma=1.0, size=None)</td>

  <td>Draw samples from a log-normal distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>logseries(p[, size])</td>

  <td>Draw samples from a logarithmic series distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>multinomial(n, pvals[, size])</td>

  <td>Draw samples from a multinomial distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>multivariate_normal(mean, cov[, size, ...)</td>

  <td>Draw random samples from a multivariate normal distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>negative_binomial(n, p[, size])</td>

  <td>Draw samples from a negative binomial distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>noncentral_chisquare(df, nonc[, size])</td>

  <td>Draw samples from a noncentral chi-square distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>noncentral_f(dfnum, dfden, nonc[, size])</td>

  <td>Draw samples from the noncentral F distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>normal(loc=0.0, scale=1.0, size=None)</td>

  <td>Draw random samples from a normal (Gaussian) distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>pareto(a[, size])</td>

  <td>Draw samples from a Pareto II or Lomax distribution with specified shape.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>poisson([lam, size])</td>

  <td>Draw samples from a Poisson distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>power(a[, size])</td>

  <td>Draws samples in [0, 1] from a power distribution with positive exponent a - 1.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>rayleigh([scale, size])</td>

  <td>Draw samples from a Rayleigh distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>standard_cauchy([size])</td>

  <td>Draw samples from a standard Cauchy distribution with mode = 0.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>standard_exponential(size=None)</td>

  <td>Draw samples from the standard exponential distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>standard_gamma(shape, size=None)</td>

  <td>Draw samples from a standard Gamma distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>standard_normal(size=None)</td>

  <td>Draw samples from a standard Normal distribution (mean=0, stdev=1).</td>

  <td></td>

  </tr>

  <tr>

  <td>standard_t(df[, size])</td>

  <td>Draw samples from a standard Student’s t distribution with df degrees of freedom.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>triangular(left, mode, right[, size])</td>

  <td>Draw samples from the triangular distribution over the interval [left, right].</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>uniform(low=0.0, high=1.0, size=None)</td>

  <td>Draw samples from a uniform distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>vonmises(mu, kappa[, size])</td>

  <td>Draw samples from a von Mises distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>wald(mean, scale, size=None)</td>

  <td>Draw samples from a Wald, or inverse Gaussian, distribution.</td>

  <td></td>

  </tr>

  <tr>

  <td>weibull(a[, size])</td>

  <td>Draw samples from a Weibull distribution.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>zipf(a[, size])</td>

  <td>Draw samples from a Zipf distribution.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  <table>

  <tbody>

  <tr>

  <th>function</th>

  <th>description</th>

  <th>notes</th>

  </tr>

  <tr>

  <td>seed(seed=None)</td>

  <td>Seed the generator.</td>

  <td></td>

  </tr>

  <tr>

  <td>get_seed()</td>

  <td>Returns the current seed of the generator.</td>

  <td>function has no counterpart in numpy</td>

  </tr>

  <tr>

  <td>get_state()</td>

  <td>Return a tuple representing the internal state of the generator.</td>

  <td>function not implemented</td>

  </tr>

  <tr>

  <td>set_state(state)</td>

  <td>Set the internal state of the generator from a tuple.</td>

  <td>function not implemented</td>

  </tr>

  </tbody>

  </table>



  *   Requires Python 3.7 or higher.
  *   Arrays may have no more than 4 axes.
  *   Cocos provides only a subset of NumPy's functions and methods. In many cases, Cocos does not support all of the parameters of its corresponding NumPy function or method.
  *   Trailing singleton dimensions are cut off, e.g. there is no difference between an array with shape (2, 2, 1) and an array with shape (2, 2) in Cocos.
  *   Matrix multiplication is not supported for integer types.


  Cocos implements multi-GPU functionality via process-based parallelism (one process per GPU device).
  It is recommended to have at least one physical CPU core per GPU in the system in order to prevent 'starving' the GPUs.


  MIT License

  Copyright (c) 2019 Michael Nowotny

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.


pkgId: 50888144c6ca604bce457a2255ed7b1a11d7f870af73842f37cdb008982a6990
name: python-cocotb-bus
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/cocotb/cocotb-bus
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotb-bus-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/dm/cocotb-bus.svg?label=PyPI%20downloads)](https://pypi.org/project/cocotb-bus/)

  The new home of the [cocotb](https://github.com/cocotb) project's pre-packaged testbenching tools and reusable bus interfaces.


pkgId: eb1a0b7bc608a993e0d56932c4d00a71c7fdc143c8fb8774a873833ed45132e2
name: python-cocotb-coverage
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Functional Coverage and Constrained Randomization Extensions for Cocotb
url: https://github.com/mciepluc/cocotb-coverage
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotb-coverage-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Functional Coverage and Constrained Randomization Extensions for Cocotb

  [![Documentation Status](https://readthedocs.org/projects/cocotb-coverage/badge/?version=latest)](http://cocotb-coverage.readthedocs.org/en/latest/)
  [![Regression Tests](https://github.com/mciepluc/cocotb-coverage/actions/workflows/main.yml/badge.svg)](https://github.com/mciepluc/cocotb-coverage/actions/workflows/main.yml)
  [![PyPI](https://img.shields.io/pypi/dm/cocotb-coverage.svg?label=PyPI%20downloads)](https://pypi.org/project/cocotb-coverage/)

  This package allows you to use constrained randomization and functional coverage techniques known from CRV (constrained random verification) and MDV (metric-driven verification) methodologies, available in SystemVerilog or _e_. Such extensions enable the implementation of an advanced verification environment for complex projects.

  The implemented functionality is intended to be easily understandable by SystemVerilog users and provides significant extensions compared to Hardware Verification Languages.

  There is an option to export coverage database to a readable XML or YML format and a function which allows for merging such files is provided.


  The package can be installed with pip. Version ```1.1.0``` is the latest one and recommended.
  ```
  pip install cocotb-coverage
  ```



  * cocotb core package - [cocotb](https://github.com/potentialventures/cocotb)
  * Constraint Solving Problem resolver used in this project - [python-constraint](https://github.com/python-constraint/python-constraint)
  * [documentation](https://cocotb-coverage.readthedocs.io/en/latest/)
  * [PyPI package](https://pypi.org/project/cocotb-coverage/1.1.dev0)
  * DVCon 2017 Paper - [New Constrained Random and MDV Methodology using Python](http://events.dvcon.org/2017/proceedings/papers/02_3.pdf)
  * DVCon 2017 Presentation - [SLIDES](http://events.dvcon.org/2017/proceedings/slides/02_3.pdf)
  * example advanced verification project - [apbi2c_cocotb_example](https://github.com/mciepluc/apbi2c_cocotb_example)


  * 1.1 released - 7 Aug 2020
  * Planned basic support for UCIS coverage database format
  * Any suggestions welcome - you are encouraged to open an issue!


  ```Python

  class Point(crv.Randomized):

      def __init__(self, x, y):
          crv.Randomized.__init__(self)
          self.x = x
          self.y = y

          self.add_rand("x", list(range(-10, 10)))
          self.add_rand("y", list(range(-10, 10)))
          
          self.add_constraint(lambda x, y: x < y)

  ...


  p = Point(0,0)

  for _ in range (10):

      
      @CoverPoint("top.x_negative", xf = lambda point : point.x < 0, bins = [True, False])
      @CoverPoint("top.y_negative", xf = lambda point : point.y < 0, bins = [True, False])
      @CoverPoint("top.xy_equal", xf = lambda point : point.x == point.y, bins = [True, False])
      @CoverCross("top.cross", items = ["top.x_negative", "top.y_negative"])
      def plot_point(point):
          ...

      p.randomize()  # randomize object
      plot_point(p)  # call a function which will sample the coverage


  coverage_db.export_to_xml(filename="coverage.xml")

  coverage_db.export_to_yaml(filename="coverage.yml")
  ```


pkgId: 968636f90ab7057b1c0d2dfa78e77e17964231dad6343cf4a6a376e86f866779
name: python-cocotb-test
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cocotb-test/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotb-test-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://dev.azure.com/themperek/themperek/_apis/build/status/themperek.cocotb-test?branchName=master)](https://dev.azure.com/themperek/themperek/_build/latest?definitionId=2&branchName=master)
  [![PyPI version](https://badge.fury.io/py/cocotb-test.svg)](https://badge.fury.io/py/cocotb-test)

  ``cocotb-test`` provides standard python unit testing capabilities for [cocotb](https://github.com/cocotb/cocotb)
  - allow the look and feel of Python unit testing
  - remove the need for Makefiles (includes Makefile compatibility mode)
  - allow easy customization of simulation flow
  - allow to use [pytest-xdist](https://pypi.org/project/pytest-xdist/) or [pytest-parallel](https://github.com/browsertron/pytest-parallel) for parallel runs



  - Install [cocotb](https://docs.cocotb.org/).

  - Install simulator (for Icarus Verilog with conda, on widows use 10.3 or devel [steveicarus/iverilog#395](https://github.com/steveicarus/iverilog/issues/395) ):
  ```bash
  conda install -c conda-forge iverilog==10.3
  ```
  - Install the package via [pip](https://pip.pypa.io/en/stable/user_guide/):
  ```bash
  pip install cocotb-test
  ```
  &emsp;or development version
  ```bash
  pip install -v https://github.com/themperek/cocotb-test/archive/master.zip
  ```
  &emsp;or
  ```bash
  git clone https://github.com/themperek/cocotb-test.git
  pip install -v -e cocotb-test
  ```

  - Create a `test_dff.py` file (check [test folder](https://github.com/themperek/cocotb-test/tree/master/tests) for more examples):
  ```python
  from cocotb_test.simulator import run
  def test_dff():
      run(
          verilog_sources=["dff.sv"], # sources
          toplevel="dff",            # top level HDL
          module="dff_cocotb"        # name of cocotb test module
      )
  ```

  - Run [pytest](https://docs.pytest.org/en/latest/contents.html) (need `dff.sv` and `dff_cocotb.py` in same directory where running `pytest`):
  ```bash
  SIM=icarus pytest -o log_cli=True test_dff.py
  ```

  - To clean (remove all `sim_build` folders):
  ```bash
  cocotb-clean -r
  ```


  * `toplevel`: Top level module name to indicate the instance in the hierarchy to use as the DUT. Multiple top levels can be specified as a list, if the simulator supports it.
  * `module`: The name of the module(s) to search for test functions (see [MODULE](https://docs.cocotb.org/en/stable/building.html?#envvar-MODULE) ).

  * `python_search` : List of additional directoreis to search for python/cocotb modules.
  * `verilog_sources`: Verilog source files to include. Can be specified as a `list` or as a `dict` of `list`s with the library name as key, if the simulator supports named libraries.
  * `vhdl_sources`: VHDL source files to include. Can be specified as a `list` or as a `dict` of `list`s with the library name as key, if the simulator supports named libraries.
  * `toplevel_lang`: see [TOPLEVEL_LANG](https://docs.cocotb.org/en/stable/building.html?#var-TOPLEVEL_LANG). (default: `verilog`)
  * `includes`: A list of directories to search for includes.
  * `defines`: A list of the defines.
  * `parameters`: A dictionary of top-level parameters/generics.
  * `compile_args`: Any arguments or flags to pass to the compile stage of the simulation.
    * `vhdl_compile_args`: Additional arguments or flags passed only when compiling VHDL sources.
    * `verilog_compile_args`: Additional arguments or flags passed only when compiling Verilog sources.
  * `sim_args`: Any arguments or flags to pass to the execution of the compiled simulation.
  * `extra_args`: Passed to both the compile and execute phases of simulators.
  * `plus_args`: plusargs arguments passed to simulator.
  * `force_compile`: Force compilation even if sources did not change. (default: `False`)
  * `compile_only`: Only compile sources. Do not run simulation. (default: `False`)
  * `testcase`: The name of the test function(s) to run (see [TESTCASE](https://docs.cocotb.org/en/stable/building.html?#envvar-TESTCASE) ).
  * `sim_build`: The directory used to compile the tests. (default: `sim_build`)
  * `work_dir`: The directory used to tun the tests. (default: same as `sim_build` argument)
  * `seed`: Seed the Python random module to recreate a previous test stimulus (see [RANDOM_SEED](https://docs.cocotb.org/en/stable/building.html?#envvar-RANDOM_SEED) ).
  * `extra_env`: A dictionary of extra environment variables set in simulator process.
  * `waves`: Enable wave dumps (not all simulators supported).
  * `timescale`: Set simulator time unit/precision (default: `None`)
  * `gui`: Starts in gui mode (not all simulators supported).
  * `make_args`: Arguments passed to make phase (`Verilator` only).




  * `SIM`: Selects which simulator to use. (default: `icarus`)
  * `WAVES`: Overwrite enable wave dumps argument. Example use `WAVES=1 pytest test_dff.py`.



  * `cocotbxml`: Combines and saves junitxml reports from cocotb tests.  Example use `pytest --cocotbxml=test-cocotb.xml`.



  * List all available test:
  ```bash
  pytest --collect-only
  ```

  * Run only selected test:
  ```bash
  pytest -k test_dff_verilog_param[3]
  ```

  * Test parameterization (for more see: [test_parameters.py](https://github.com/themperek/cocotb-test/blob/master/tests/test_parameters.py) )

  ```python
  @pytest.mark.parametrize("width", [{"WIDTH_IN": "8"}, {"WIDTH_IN": "16"}])
  def test_dff_verilog_testcase(width):
      run(
          ...
          parameters=width,
          sim_build="sim_build/" + "_".join(("{}={}".format(*i) for i in width.items())),
      )
  ```

  *  Run test in parallel (after installing  [pytest-xdist](https://pypi.org/project/pytest-xdist/) )
  ```bash
  pytest -n NUMCPUS
  ```


  For cocotb tests/examples install cocotb in editable mode
  ```bash
  git clone https://github.com/potentialventures/cocotb.git
  pip install -e cocotb
  SIM=icarus pytest -o log_cli=True --junitxml=test-results.xml --cocotbxml=test-cocotb.xml tests
  ```


  - [pytest logging](https://docs.pytest.org/en/stable/logging.html) - pytest logging documentation
  - [pytest-xdist](https://pypi.org/project/pytest-xdist/) - test run parallelization (see [test_parallel](https://github.com/themperek/cocotb-test/blob/master/tests/test_parallel.py))
  - [pytest-parallel](https://github.com/browsertron/pytest-parallel) - parallel and concurrent testing  (see [test_parallel](https://github.com/themperek/cocotb-test/blob/master/tests/test_parallel.py))
  - [pytest-html](https://github.com/pytest-dev/pytest-html) - generates a HTML report for the test results
  - [pytest-sugar](https://github.com/Teemu/pytest-sugar/) - sugar


pkgId: b8c33bc0b3ab54a188e97b0d5c0ca51b61e38dcbe8f468eea5176595520214bb
name: python-cocotbext-axi
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: AXI, AXI lite, and AXI stream modules for cocotb
url: https://github.com/alexforencich/cocotbext-axi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotbext-axi-0.1.24-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/alexforencich/cocotbext-axi/workflows/Regression%20Tests/badge.svg?branch=master)](https://github.com/alexforencich/cocotbext-axi/actions/)
  [![codecov](https://codecov.io/gh/alexforencich/cocotbext-axi/branch/master/graph/badge.svg)](https://codecov.io/gh/alexforencich/cocotbext-axi)
  [![PyPI version](https://badge.fury.io/py/cocotbext-axi.svg)](https://pypi.org/project/cocotbext-axi)
  [![Downloads](https://pepy.tech/badge/cocotbext-axi)](https://pepy.tech/project/cocotbext-axi)

  GitHub repository: https://github.com/alexforencich/cocotbext-axi



  AXI, AXI lite, and AXI stream simulation models for [cocotb](https://github.com/cocotb/cocotb).



  Installation from pip (release version, stable):

      $ pip install cocotbext-axi

  Installation from git (latest development version, potentially unstable):

      $ pip install https://github.com/alexforencich/cocotbext-axi/archive/master.zip

  Installation for active development:

      $ git clone https://github.com/alexforencich/cocotbext-axi
      $ pip install -e cocotbext-axi



  See the `tests` directory, [verilog-axi](https://github.com/alexforencich/verilog-axi), and [verilog-axis](https://github.com/alexforencich/verilog-axis) for complete testbenches using these modules.



  The `AxiMaster` and `AxiLiteMaster` classes implement AXI masters and are capable of generating read and write operations against AXI slaves.  Requested operations will be split and aligned according to the AXI specification.  The `AxiMaster` module is capable of generating narrow bursts, handling multiple in-flight operations, and handling reordering and interleaving in responses across different transaction IDs.  `AxiMaster` and `AxiLiteMaster` and related objects all extend `Region`, so they can be attached to `AddressSpace` objects to handle memory operations in the specified region.

  The `AxiMaster` is a wrapper around `AxiMasterWrite` and `AxiMasterRead`.  Similarly, `AxiLiteMaster` is a wrapper around `AxiLiteMasterWrite` and `AxiLiteMasterRead`.  If a read-only or write-only interface is required instead of a full interface, use the corresponding read-only or write-only variant, the usage and API are exactly the same.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.axi import AxiBus, AxiMaster

      axi_master = AxiMaster(AxiBus.from_prefix(dut, "s_axi"), dut.clk, dut.rst)

  The first argument to the constructor accepts an `AxiBus` or `AxiLiteBus` object, as appropriate.  These objects are containers for the interface signals and include class methods to automate connections.

  Once the module is instantiated, read and write operations can be initiated in a couple of different ways.

  First, operations can be carried out with async blocking `read()`, `write()`, and their associated word-access wrappers.  Multiple concurrent operations started from different coroutines are handled correctly, with results returned in the order that the operations complete.  For example:

      await axi_master.write(0x0000, b'test')
      data = await axi_master.read(0x0000, 4)

  Additional parameters can be specified to control sideband signals and burst settings.  The transfer will be split into one or more bursts according to the AXI specification.  All bursts generated from the same call to `read()` or `write()` will use the same ID, which will be automatically generated if not specified.  `read()` and `write()` return `namedtuple` objects containing _address_, _data_ or _length_, and _resp_.  This is the preferred style, and this is the only style supported by the word-access wrappers.

  Alternatively, operations can be initiated with non-blocking `init_read()` and `init_write()`.  These functions return `Event` objects which are triggered when the operation completes, and the result can be retrieved from `Event.data`.  For example:

      write_op = axi_master.init_write(0x0000, b'test')
      await write_op.wait()
      resp = write_op.data
      read_op = axi_master.init_read(0x0000, 4)
      await read_op.wait()
      resp = read_op.data

  With this method, it is possible to start multiple concurrent operations from the same coroutine.  It is also possible to use the events with `Combine`, `First`, and `with_timeout`.



  * _bus_: `AxiBus` or `AxiLiteBus` object containing AXI interface signals
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _reset_active_level_: reset active level (optional, default `True`)



  * _max_burst_len_: maximum burst length in cycles, range 1-256, default 256.



  * `init_read(address, length, ...)`: initiate reading _length_ bytes, starting at _address_.  Returns an `Event` object.
  * `init_write(address, data, ...)`: initiate writing _data_ (bytes), starting from _address_.  Returns an `Event` object.
  * `idle()`: returns _True_ when there are no outstanding operations in progress
  * `wait()`: blocking wait until all outstanding operations complete
  * `wait_read()`: wait until all outstanding read operations complete
  * `wait_write()`: wait until all outstanding write operations complete
  * `read(address, length, ...)`: read _length_ bytes, starting at _address_
  * `read_words(address, count, byteorder='little', ws=2, ...)`: read _count_ _ws_-byte words, starting at _address_
  * `read_dwords(address, count, byteorder='little', ...)`: read _count_ 4-byte dwords, starting at _address_
  * `read_qwords(address, count, byteorder='little', ...)`: read _count_ 8-byte qwords, starting at _address_
  * `read_byte(address, ...)`: read single byte at _address_
  * `read_word(address, byteorder='little', ws=2, ...)`: read single _ws_-byte word at _address_
  * `read_dword(address, byteorder='little', ...)`: read single 4-byte dword at _address_
  * `read_qword(address, byteorder='little', ...)`: read single 8-byte qword at _address_
  * `write(address, data, ...)`: write _data_ (bytes), starting at _address_
  * `write_words(address, data, byteorder='little', ws=2, ...)`: write _data_ (_ws_-byte words), starting at _address_
  * `write_dwords(address, data, byteorder='little', ...)`: write _data_ (4-byte dwords), starting at _address_
  * `write_qwords(address, data, byteorder='little', ...)`: write _data_ (8-byte qwords), starting at _address_
  * `write_byte(address, data, ...)`: write single byte at _address_
  * `write_word(address, data, byteorder='little', ws=2, ...)`: write single _ws_-byte word at _address_
  * `write_dword(address, data, byteorder='little', ...)`: write single 4-byte dword at _address_
  * `write_qword(address, data, byteorder='little', ...)`: write single 8-byte qword at _address_



  * _arid_,_awid_: AXI ID for bursts, default automatically assigned
  * _burst_: AXI burst type, default `AxiBurstType.INCR`
  * _size_: AXI burst size, default maximum supported by interface
  * _lock_: AXI lock type, default `AxiLockType.NORMAL`
  * _cache_: AXI cache field, default `0b0011`
  * _prot_: AXI protection flags, default `AxiProt.NONSECURE`
  * _qos_: AXI QOS field, default `0`
  * _region_: AXI region field, default `0`
  * _user_: AXI user signal (awuser/aruser), default `0`
  * _wuser_: AXI wuser signal, default `0` (write-related methods only)
  * _event_: `Event` object used to wait on and retrieve result for specific operation, default `None`.  The event will be triggered when the operation completes and the result returned via `Event.data`.  (`init_read()` and `init_write()` only)



  * _prot_: AXI protection flags, default `AxiProt.NONSECURE`
  * _event_: `Event` object used to wait on and retrieve result for specific operation, default `None`.  The event will be triggered when the operation completes and the result returned via `Event.data`.  (`init_read()` and `init_write()` only)



  The `AxiBus`, `AxiLiteBus`, and related objects are containers for the interface signals.  These hold instances of bus objects for the individual channels, which are currently extensions of `cocotb_bus.bus.Bus`.  Class methods `from_entity` and `from_prefix` are provided to facilitate signal name matching.  For AXI interfaces use `AxiBus`, `AxiReadBus`, or `AxiWriteBus`, as appropriate.  For AXI lite interfaces, use `AxiLiteBus`, `AxiLiteReadBus`, or `AxiLiteWriteBus`, as appropriate.



  The `AxiSlave` and `AxiLiteSlave` classes implement AXI slaves and are capable of completing read and write operations from upstream AXI masters.  The `AxiSlave` module is capable of handling narrow bursts.  These modules can either be used to perform memory reads and writes on a `MemoryInterface` on behalf of the DUT, or they can be extended to implement customized functionality.

  The `AxiSlave` is a wrapper around `AxiSlaveWrite` and `AxiSlaveRead`.  Similarly, `AxiLiteSlave` is a wrapper around `AxiLiteSlaveWrite` and `AxiLiteSlaveRead`.  If a read-only or write-only interface is required instead of a full interface, use the corresponding read-only or write-only variant, the usage and API are exactly the same.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.axi import AxiBus, AxiSlave, MemoryRegion

      axi_slave = AxiSlave(AxiBus.from_prefix(dut, "m_axi"), dut.clk, dut.rst)
      region = MemoryRegion(2**axi_slave.read_if.address_width)
      axi_slave.target = region

  The first argument to the constructor accepts an `AxiBus` or `AxiLiteBus` object.  These objects are containers for the interface signals and include class methods to automate connections.

  It is also possible to extend these modules; operation can be customized by overriding the internal `_read()` and `_write()` methods.  See `AxiRam` and `AxiLiteRam` for an example.



  * _bus_: `AxiBus` or `AxiLiteBus` object containing AXI interface signals
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _reset_active_level_: reset active level (optional, default `True`)
  * _target_: target region (optional, default `None`)



  * _target_: target region



  The `AxiRam` and `AxiLiteRam` classes implement AXI RAMs and are capable of completing read and write operations from upstream AXI masters.  The `AxiRam` module is capable of handling narrow bursts.  These modules are extensions of the corresponding `AxiSlave` and `AxiLiteSlave` modules.  Internally, `SparseMemory` is used to support emulating very large memories.

  The `AxiRam` is a wrapper around `AxiRamWrite` and `AxiRamRead`.  Similarly, `AxiLiteRam` is a wrapper around `AxiLiteRamWrite` and `AxiLiteRamRead`.  If a read-only or write-only interface is required instead of a full interface, use the corresponding read-only or write-only variant, the usage and API are exactly the same.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.axi import AxiBus, AxiRam

      axi_ram = AxiRam(AxiBus.from_prefix(dut, "m_axi"), dut.clk, dut.rst, size=2**32)

  The first argument to the constructor accepts an `AxiBus` or `AxiLiteBus` object.  These objects are containers for the interface signals and include class methods to automate connections.

  Once the module is instantiated, the memory contents can be accessed in a couple of different ways.  First, the `mmap` object can be accessed directly via the `mem` attribute.  Second, `read()`, `write()`, and various word-access wrappers are available.  Hex dump helper methods are also provided for debugging.  For example:

      axi_ram.write(0x0000, b'test')
      data = axi_ram.read(0x0000, 4)
      axi_ram.hexdump(0x0000, 4, prefix="RAM")

  Multi-port memories can be constructed by passing the `mem` object of the first instance to the other instances.  For example, here is how to create a four-port RAM:

      axi_ram_p1 = AxiRam(AxiBus.from_prefix(dut, "m00_axi"), dut.clk, dut.rst, size=2**32)
      axi_ram_p2 = AxiRam(AxiBus.from_prefix(dut, "m01_axi"), dut.clk, dut.rst, mem=axi_ram_p1.mem)
      axi_ram_p3 = AxiRam(AxiBus.from_prefix(dut, "m02_axi"), dut.clk, dut.rst, mem=axi_ram_p1.mem)
      axi_ram_p4 = AxiRam(AxiBus.from_prefix(dut, "m03_axi"), dut.clk, dut.rst, mem=axi_ram_p1.mem)



  * _bus_: `AxiBus` or `AxiLiteBus` object containing AXI interface signals
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _reset_active_level_: reset active level (optional, default `True`)
  * _size_: memory size in bytes (optional, default `2**64`)
  * _mem_: `mmap` or `SparseMemory` backing object to use (optional, overrides _size_)



  * _mem_: directly access shared `mmap` or `SparseMemory` backing object



  * `read(address, length)`: read _length_ bytes, starting at _address_
  * `read_words(address, count, byteorder='little', ws=2)`: read _count_ _ws_-byte words, starting at _address_
  * `read_dwords(address, count, byteorder='little')`: read _count_ 4-byte dwords, starting at _address_
  * `read_qwords(address, count, byteorder='little')`: read _count_ 8-byte qwords, starting at _address_
  * `read_byte(address)`: read single byte at _address_
  * `read_word(address, byteorder='little', ws=2)`: read single _ws_-byte word at _address_
  * `read_dword(address, byteorder='little')`: read single 4-byte dword at _address_
  * `read_qword(address, byteorder='little')`: read single 8-byte qword at _address_
  * `write(address, data)`: write _data_ (bytes), starting at _address_
  * `write_words(address, data, byteorder='little', ws=2)`: write _data_ (_ws_-byte words), starting at _address_
  * `write_dwords(address, data, byteorder='little')`: write _data_ (4-byte dwords), starting at _address_
  * `write_qwords(address, data, byteorder='little')`: write _data_ (8-byte qwords), starting at _address_
  * `write_byte(address, data)`: write single byte at _address_
  * `write_word(address, data, byteorder='little', ws=2)`: write single _ws_-byte word at _address_
  * `write_dword(address, data, byteorder='little')`: write single 4-byte dword at _address_
  * `write_qword(address, data, byteorder='little')`: write single 8-byte qword at _address_
  * `hexdump(address, length, prefix='')`: print hex dump of _length_ bytes starting from _address_, prefix lines with optional _prefix_
  * `hexdump_line(address, length, prefix='')`: return hex dump (list of str) of _length_ bytes starting from _address_, prefix lines with optional _prefix_
  * `hexdump_str(address, length, prefix='')`: return hex dump (str) of _length_ bytes starting from _address_, prefix lines with optional _prefix_



  The `AxiStreamSource`, `AxiStreamSink`, and `AxiStreamMonitor` classes can be used to drive, receive, and monitor traffic on AXI stream interfaces.  The `AxiStreamSource` drives all signals except for `tready` and can be used to drive AXI stream traffic into a design.  The `AxiStreamSink` drives the `tready` line only and as such can receive AXI stream traffic and exert backpressure.  The `AxiStreamMonitor` drives no signals and as such can be connected to AXI stream interfaces anywhere within a design to passively monitor traffic.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.axi import (AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamMonitor)

      axis_source = AxiStreamSource(AxiStreamBus.from_prefix(dut, "s_axis"), dut.clk, dut.rst)
      axis_sink = AxiStreamSink(AxiStreamBus.from_prefix(dut, "m_axis"), dut.clk, dut.rst)
      axis_mon= AxiStreamMonitor(AxiStreamBus.from_prefix(dut.inst, "int_axis"), dut.clk, dut.rst)

  The first argument to the constructor accepts an `AxiStreamBus` object.  This object is a container for the interface signals and includes class methods to automate connections.

  To send data into a design with an `AxiStreamSource`, call `send()`/`send_nowait()` or `write()`/`write_nowait()`.  Accepted data types are iterables or `AxiStreamFrame` objects.  Optionally, call `wait()` to wait for the transmit operation to complete.  Example:

      await axis_source.send(b'test data')
      
      await axis_source.wait()

  It is also possible to wait for the transmission of a specific frame to complete by passing an event in the tx_complete field of the `AxiStreamFrame` object, and then awaiting the event.  The frame, with simulation time fields set, will be returned in the event data.  Example:

      frame = AxiStreamFrame(b'test data', tx_complete=Event())
      await axis_source.send(frame)
      await frame.tx_complete.wait()
      print(frame.tx_complete.data.sim_time_start)

  To receive data with an `AxiStreamSink` or `AxiStreamMonitor`, call `recv()`/`recv_nowait()` or `read()`/`read_nowait()`.  Optionally call `wait()` to wait for new receive data.  `recv()` is intended for use with a frame-oriented interface, and by default compacts `AxiStreamFrame`s before returning them.  `read()` is intended for non-frame-oriented streams.  Calling `read()` internally calls `recv()` for all frames currently in the queue, then compacts and coalesces `tdata` from all frames into a separate read queue, from which read data is returned.  All sideband data is discarded.

      data = await axis_sink.recv()



  * `tdata`: data, required
  * `tvalid`: qualifies all other signals; optional, assumed `1` when absent
  * `tready`: indicates sink is ready for data; optional, assumed `1` when absent
  * `tlast`: marks the last cycle of a frame; optional, assumed `1` when absent
  * `tkeep`: qualifies data byte, data bus width must be evenly divisible by `tkeep` signal width; optional, assumed `1` when absent
  * `tid`: ID signal, can be used for routing; optional, assumed `0` when absent
  * `tdest`: destination signal, can be used for routing; optional, assumed `0` when absent
  * `tuser`: additional user data; optional, assumed `0` when absent



  * _bus_: `AxiStreamBus` object containing AXI stream interface signals
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _reset_active_level_: reset active level (optional, default `True`)
  * _byte_size_: byte size (optional)
  * _byte_lanes_: byte lane count (optional)

  Note: _byte_size_, _byte_lanes_, `len(tdata)`, and `len(tkeep)` are all related, in that _byte_lanes_ is set from `tkeep` if it is connected, and `byte_size*byte_lanes == len(tdata)`.  So, if `tkeep` is connected, both _byte_size_ and _byte_lanes_ will be computed internally and cannot be overridden.  If `tkeep` is not connected, then either _byte_size_ or _byte_lanes_ can be specified, and the other will be computed such that `byte_size*byte_lanes == len(tdata)`.



  * _pause_: stall the interface (deassert `tready` or `tvalid`) (source/sink only)
  * _queue_occupancy_bytes_: number of bytes in queue (all)
  * _queue_occupancy_frames_: number of frames in queue (all)
  * _queue_occupancy_limit_bytes_: max number of bytes in queue allowed before backpressure is applied (source/sink only)
  * _queue_occupancy_limit_frames_: max number of frames in queue allowed before backpressure is applied (source/sink only)



  * `send(frame)`: send _frame_ (blocking) (source)
  * `send_nowait(frame)`: send _frame_ (non-blocking) (source)
  * `write(data)`: send _data_ (alias of send) (blocking) (source)
  * `write_nowait(data)`: send _data_ (alias of send_nowait) (non-blocking) (source)
  * `recv(compact=True)`: receive a frame as a `GmiiFrame` (blocking) (sink)
  * `recv_nowait(compact=True)`: receive a frame as a `GmiiFrame` (non-blocking) (sink)
  * `read(count)`: read _count_ bytes from buffer (blocking) (sink/monitor)
  * `read_nowait(count)`: read _count_ bytes from buffer (non-blocking) (sink/monitor)
  * `count()`: returns the number of items in the queue (all)
  * `empty()`: returns _True_ if the queue is empty (all)
  * `full()`: returns _True_ if the queue occupancy limits are met (source/sink)
  * `idle()`: returns _True_ if no transfer is in progress (all) or if the queue is not empty (source)
  * `clear()`: drop all data in queue (all)
  * `wait()`: wait for idle (source)
  * `wait(timeout=0, timeout_unit='ns')`: wait for frame received (sink)
  * `set_pause_generator(generator)`: set generator for pause signal, generator will be advanced on every clock cycle (source/sink)
  * `clear_pause_generator()`: remove generator for pause signal (source/sink)



  The `AxiStreamBus` object is a container for the interface signals.  Currently, it is an extension of `cocotb.bus.Bus`.  Class methods `from_entity` and `from_prefix` are provided to facilitate signal name matching.



  The `AxiStreamFrame` object is a container for a frame to be transferred via AXI stream.  The `tdata` field contains the packet data in the form of a list of bytes, which is either a `bytearray` if the byte size is 8 bits or a `list` of `int`s otherwise.  `tkeep`, `tid`, `tdest`, and `tuser` can either be `None`, an `int`, or a `list` of `int`s.

  Attributes:

  * `tdata`: bytes, bytearray, or list
  * `tkeep`: tkeep field, optional; list, each entry qualifies the corresponding entry in `tdata`.  Can be used to insert gaps on the source side.
  * `tid`: tid field, optional; int or list with one entry per `tdata`, last value used per cycle when sending.
  * `tdest`: tdest field, optional; int or list with one entry per `tdata`, last value used per cycle when sending.
  * `tuser`: tuser field, optional; int or list with one entry per `tdata`, last value used per cycle when sending.
  * `sim_time_start`: simulation time of first transfer cycle of frame.
  * `sim_time_end`: simulation time of last transfer cycle of frame.
  * `tx_complete`: event or callable triggered when frame is transmitted.

  Methods:

  * `normalize()`: pack `tkeep`, `tid`, `tdest`, and `tuser` to the same length as `tdata`, replicating last element if necessary, initialize `tkeep` to list of `1` and `tid`, `tdest`, and `tuser` to list of `0` if not specified.
  * `compact()`: remove `tdata`, `tid`, `tdest`, and `tuser` values based on `tkeep`, remove `tkeep`, compact `tid`, `tdest`, and `tuser` to an int if all values are identical.



  The address space abstraction provides a framework for cross-connecting multiple memory-mapped interfaces for testing components that interface with complex systems, including components with DMA engines.

  `MemoryInterface` is the base class for all components in the address space abstraction.  `MemoryInterface` provides the core `read()` and `write()` methods, which implement bounds checking, as well as word-access wrappers.  Methods for creating `Window` and `WindowPool` objects are also provided.  The function `get_absolute_address()` translates addresses to the system address space.  `MemoryInterface` can be extended to implement custom functionality by overriding `_read()` and `_write()`.

  `Window` objects represent views onto a parent address space with some length and offset.  `read()` and `write()` operations on a `Window` are translated to the equivalent operations on the parent address space.  Multiple `Window` instances can overlap and access the same portion of address space.

  `WindowPool` provides a method for dynamically allocating windows from a section of address space.  It uses a standard memory management algorithm to provide naturally-aligned `Window` objects of the requested size.

  `Region` is the base class for all components which implement a portion of address space.  `Region` objects can be registered with `AddressSpace` objects to handle `read()` and `write()` operations in a specified region.  `Region` can be extended by components that implement a portion of address space.

  `MemoryRegion` is an extension of `Region` that uses an `mmap` instance to handle memory operations.  `MemoryRegion` also provides hex dump methods as well as indexing and slicing.

  `SparseMemoryRegion` is similar to `MemoryRegion` but is backed by `SparseMemory` instead of `mmap` and as such can emulate extremely large regions of address space.

  `PeripheralRegion` is an extension of `Region` that can wrap another object that implements `read()` and `write()`, as an alternative to extending `Region`.

  `AddressSpace` is the core object for handling address spaces.  `Region` objects can be registered with `AddressSpace` with specified base address, size, and offset.  The `AddressSpace` object will then direct `read()` and `write()` operations to the appropriate `Region`s, splitting requests appropriately when necessary and translating addresses.  Regions registered with `offset` other than `None` are translated such that accesses to base address + N map to N + offset.  Regions registered with an `offset` of `None` are not translated.  `Region` objects registered with the same `AddressSpace` cannot overlap, however the same `Region` can be registered multiple times.  `AddressSpace` also provides a method for creating `Pool` objects.

  `Pool` is an extension of `AddressSpace` that supports dynamic allocation of `MemoryRegion`s.  It uses a standard memory management algorithm to provide naturally-aligned `MemoryRegion` objects of the requested size.



  This is a simple example that shows how the address space abstraction components can be used to connect a DUT to a simulated host system, including simulated RAM, an AXI interface from the DUT for DMA, and an AXI lite interface to the DUT for control.

      from cocotbext.axi import AddressSpace, SparseMemoryRegion
      from cocotbext.axi import AxiBus, AxiLiteMaster, AxiSlave

      
      address_space = AddressSpace(2**32)

      
      ram = SparseMemoryRegion(2**24)
      address_space.register_region(ram, 0x0000_0000)
      ram_pool = address_space.create_window_pool(0x0000_0000, 2**20)

      
      axil_master = AxiLiteMaster(AxiLiteBus.from_prefix(dut, "s_axil_ctrl"), dut.clk, dut.rst)
      address_space.register_region(axil_master, 0x8000_0000)
      ctrl_regs = address_space.create_window(0x8000_0000, axil_master.size)

      
      axi_slave = AxiSlave(AxiBus.from_prefix(dut, "m_axi_dma"), dut.clk, dut.rst, target=address_space)

      
      src_block = ram_pool.alloc_window(1024)
      dst_block = ram_pool.alloc_window(1024)

      test_data = b'test data'
      await src_block.write(0, test_data)

      await ctrl_regs.write_dword(DMA_SRC_ADDR, src_block.get_absolute_address(0))
      await ctrl_regs.write_dword(DMA_DST_ADDR, dst_block.get_absolute_address(0))
      await ctrl_regs.write_dword(DMA_LEN, len(test_data))
      await ctrl_regs.write_dword(DMA_CONTROL, 1)

      while await ctrl_regs.read_dword(DMA_STATUS) == 0:
          pass

      assert await dst_block.read(0, len(test_data)) == test_data



  * Write address channel
      * `awid`: transaction ID
      * `awaddr`: address
      * `awlen`: burst length (cycles)
      * `awsize`: burst size (bytes/cycle)
      * `awburst`: burst type
      * `awlock`: lock type
      * `awcache`: cache control
      * `awprot`: protection bits
      * `awqos`: QoS field
      * `awregion`: region field
      * `awuser`: additional user sideband data
      * `awvalid`: valid signal, qualifies all channel fields
      * `awready`: ready signal, back-pressure from sink
  * Write data channel
      * `wdata`: write data
      * `wstrb`: write strobe
      * `wlast`: end of burst flag
      * `wuser`: additional user sideband data
      * `wvalid`: valid signal, qualifies all channel fields
      * `wready`: ready signal, back-pressure from sink
  * Write response channel
      * `bid`: transaction ID
      * `bresp`: write response
      * `buser`: additional user sideband data
      * `bvalid`: valid signal, qualifies all channel fields
      * `bready`: ready signal, back-pressure from sink
  * Read address channel
      * `arid`: transaction ID
      * `araddr`: address
      * `arlen`: burst length (cycles)
      * `arsize`: burst size (bytes/cycle)
      * `arburst`: burst type
      * `arlock`: lock type
      * `arcache`: cache control
      * `arprot`: protection bits
      * `arqos`: QoS field
      * `arregion`: region field
      * `aruser`: additional user sideband data
      * `arvalid`: valid signal, qualifies all channel fields
      * `arready`: ready signal, back-pressure from sink
  * Read data channel
      * `rid`: transaction ID
      * `rdata`: read data
      * `rresp`: read response
      * `rlast`: end of burst flag
      * `ruser`: additional user sideband data
      * `rvalid`: valid signal, qualifies all channel fields
      * `rready`: ready signal, back-pressure from sink



  * Write address channel
      * `awaddr`: address
      * `awprot`: protection bits
      * `awvalid`: valid signal, qualifies all channel fields
      * `awready`: ready signal, back-pressure from sink
  * Write data channel
      * `wdata`: write data
      * `wstrb`: write strobe
      * `wvalid`: valid signal, qualifies all channel fields
      * `wready`: ready signal, back-pressure from sink
  * Write response channel
      * `bresp`: write response
      * `bvalid`: valid signal, qualifies all channel fields
      * `bready`: ready signal, back-pressure from sink
  * Read address channel
      * `araddr`: address
      * `arprot`: protection bits
      * `arvalid`: valid signal, qualifies all channel fields
      * `arready`: ready signal, back-pressure from sink
  * Read data channel
      * `rdata`: read data
      * `rresp`: read response
      * `rvalid`: valid signal, qualifies all channel fields
      * `rready`: ready signal, back-pressure from sink



  * `tdata`: data
  * `tvalid`: qualifies all other signals
  * `tready`: indicates sink is ready for data
  * `tlast`: marks the last cycle of a frame
  * `tkeep`: qualifies data bytes in `tdata`
  * `tid`: ID signal, can be used for routing
  * `tdest`: destination signal, can be used for routing
  * `tuser`: additional sideband data


pkgId: 4ad088adf3639c2475728347280525945342c80e366cc0aec07c7da451aca9d8
name: python-cocotbext-eth
arch: src
version: 0.1.22
epoch: 0
release: 1
summary: Ethernet interface modules for cocotb
url: https://github.com/alexforencich/cocotbext-eth
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotbext-eth-0.1.22-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/alexforencich/cocotbext-eth/workflows/Regression%20Tests/badge.svg?branch=master)](https://github.com/alexforencich/cocotbext-eth/actions/)
  [![codecov](https://codecov.io/gh/alexforencich/cocotbext-eth/branch/master/graph/badge.svg)](https://codecov.io/gh/alexforencich/cocotbext-eth)
  [![PyPI version](https://badge.fury.io/py/cocotbext-eth.svg)](https://pypi.org/project/cocotbext-eth)
  [![Downloads](https://pepy.tech/badge/cocotbext-eth)](https://pepy.tech/project/cocotbext-eth)

  GitHub repository: https://github.com/alexforencich/cocotbext-eth



  Ethernet interface models for [cocotb](https://github.com/cocotb/cocotb).

  Includes PHY-attach interface models for MII, GMII, RGMII, and XGMII; PHY chip interface models for MII, GMII, and RGMII; PTP clock simulation models; and a generic Ethernet MAC model that supports rate enforcement and PTP timestamping.



  Installation from pip (release version, stable):

      $ pip install cocotbext-eth

  Installation from git (latest development version, potentially unstable):

      $ pip install https://github.com/alexforencich/cocotbext-eth/archive/master.zip

  Installation for active development:

      $ git clone https://github.com/alexforencich/cocotbext-eth
      $ pip install -e cocotbext-eth



  See the `tests` directory, [verilog-ethernet](https://github.com/alexforencich/verilog-ethernet), and [corundum](https://github.com/corundum/corundum) for complete testbenches using these modules.



  The `GmiiSource` and `GmiiSink` classes can be used to drive, receive, and monitor GMII traffic.  The `GmiiSource` drives GMII traffic into a design.  The `GmiiSink` receives GMII traffic, including monitoring internal interfaces.  The `GmiiPhy` class is a wrapper around `GmiiSource` and `GmiiSink` that also provides clocking and rate-switching to emulate a GMII PHY chip.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.eth import GmiiSource, GmiiSink

      gmii_source = GmiiSource(dut.rxd, dut.rx_er, dut.rx_en, dut.clk, dut.rst)
      gmii_sink = GmiiSink(dut.txd, dut.tx_er, dut.tx_en, dut.clk, dut.rst)

  To send data into a design with a `GmiiSource`, call `send()` or `send_nowait()`.  Accepted data types are iterables that can be converted to bytearray or `GmiiFrame` objects.  Optionally, call `wait()` to wait for the transmit operation to complete.  Example:

      await gmii_source.send(GmiiFrame.from_payload(b'test data'))
      
      await gmii_source.wait()

  It is also possible to wait for the transmission of a specific frame to complete by passing an event in the tx_complete field of the `GmiiFrame` object, and then awaiting the event.  The frame, with simulation time fields set, will be returned in the event data.  Example:

      frame = GmiiFrame.from_payload(b'test data', tx_complete=Event())
      await gmii_source.send(frame)
      await frame.tx_complete.wait()
      print(frame.tx_complete.data.sim_time_sfd)

  To receive data with a `GmiiSink`, call `recv()` or `recv_nowait()`.  Optionally call `wait()` to wait for new receive data.

      data = await gmii_sink.recv()

  The `GmiiPhy` class provides a model of a GMII PHY chip.  It wraps instances of `GmiiSource` (`rx`) and `GmiiSink` (`tx`), provides the necessary clocking components, and provides the `set_speed()` method to change the link speed.  `set_speed()` changes the `tx_clk` and `rx_clk` frequencies, switches between `gtx_clk` and `tx_clk`, and selects the appropriate mode (MII or GMII) on the source and sink instances.  In general, the `GmiiPhy` class is intended to be used for integration tests where the design expects to be directly connected to an external GMII PHY chip and contains all of the necessary IO and clocking logic.  Example:

      from cocotbext.eth import GmiiFrame, GmiiPhy

      gmii_phy = GmiiPhy(dut.txd, dut.tx_er, dut.tx_en, dut.tx_clk, dut.gtx_clk,
          dut.rxd, dut.rx_er, dut.rx_en, dut.rx_clk, dut.rst, speed=1000e6)

      gmii_phy.set_speed(100e6)

      await gmii_phy.rx.send(GmiiFrame.from_payload(b'test RX data'))
      tx_data = await gmii_phy.tx.recv()



  * `txd`, `rxd`: data
  * `tx_er`, `rx_er`: error (when asserted with `tx_en` or `rx_dv`)
  * `tx_en`, `rx_dv`: data valid



  * _data_: data signal (txd, rxd, etc.)
  * _er_: error signal (tx_er, rx_er, etc.) (optional)
  * _dv_: data valid signal (tx_en, rx_dv, etc.)
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _enable_: clock enable (optional)
  * _mii_select_: MII mode select (optional)
  * _reset_active_level_: reset active level (optional, default `True`)



  * _queue_occupancy_bytes_: number of bytes in queue
  * _queue_occupancy_frames_: number of frames in queue
  * _queue_occupancy_limit_bytes_: max number of bytes in queue allowed before backpressure is applied (source only)
  * _queue_occupancy_limit_frames_: max number of frames in queue allowed before backpressure is applied (source only)
  * _mii_mode_: control MII mode when _mii_select_ signal is not connected



  * `send(frame)`: send _frame_ (blocking) (source)
  * `send_nowait(frame)`: send _frame_ (non-blocking) (source)
  * `recv()`: receive a frame as a `GmiiFrame` (blocking) (sink)
  * `recv_nowait()`: receive a frame as a `GmiiFrame` (non-blocking) (sink)
  * `count()`: returns the number of items in the queue (all)
  * `empty()`: returns _True_ if the queue is empty (all)
  * `full()`: returns _True_ if the queue occupancy limits are met (source)
  * `idle()`: returns _True_ if no transfer is in progress (all) or if the queue is not empty (source)
  * `clear()`: drop all data in queue (all)
  * `wait()`: wait for idle (source)
  * `wait(timeout=0, timeout_unit='ns')`: wait for frame received (sink)



  Example transfer via GMII at 1 Gbps:

                    __    __    __    __    _       __    __    __    __
      tx_clk     __/  \__/  \__/  \__/  \__/  ... _/  \__/  \__/  \__/  \__
                          _____ _____ _____ _     _ _____ _____
      tx_d[7:0]  XXXXXXXXX_55__X_55__X_55__X_ ... _X_72__X_fb__XXXXXXXXXXXX

      tx_er      ____________________________ ... _________________________
                          ___________________     _____________
      tx_en      ________/                    ...              \___________




  The `GmiiFrame` object is a container for a frame to be transferred via GMII.  The `data` field contains the packet data in the form of a list of bytes.  `error` contains the `er` signal level state associated with each byte as a list of ints.

  Attributes:

  * `data`: bytearray
  * `error`: error field, optional; list, each entry qualifies the corresponding entry in `data`.
  * `sim_time_start`: simulation time of first transfer cycle of frame.
  * `sim_time_sfd`: simulation time at which the SFD was transferred.
  * `sim_time_end`: simulation time of last transfer cycle of frame.
  * `start_lane`: byte lane in which the start control character was transferred.
  * `tx_complete`: event or callable triggered when frame is transmitted.

  Methods:

  * `from_payload(payload, min_len=60)`: create `GmiiFrame` from payload data, inserts preamble, zero-pads frame to minimum length and computes and inserts FCS (class method)
  * `from_raw_payload(payload)`: create `GmiiFrame` from payload data, inserts preamble only (class method)
  * `get_preamble_len()`: locate SFD and return preamble length
  * `get_preamble()`: return preamble
  * `get_payload(strip_fcs=True)`: return payload, optionally strip FCS
  * `get_fcs()`: return FCS
  * `check_fcs()`: returns _True_ if FCS is correct
  * `normalize()`: pack `error` to the same length as `data`, replicating last element if necessary, initialize to list of `0` if not specified.
  * `compact()`: remove `error` if all zero



  The `MiiSource` and `MiiSink` classes can be used to drive, receive, and monitor MII traffic.  The `MiiSource` drives MII traffic into a design.  The `MiiSink` receives MII traffic, including monitoring internal interfaces.  The `MiiPhy` class is a wrapper around `MiiSource` and `MiiSink` that also provides clocking and rate-switching to emulate an MII PHY chip.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.eth import MiiSource, MiiSink

      mii_source = MiiSource(dut.rxd, dut.rx_er, dut.rx_en, dut.clk, dut.rst)
      mii_sink = MiiSink(dut.txd, dut.tx_er, dut.tx_en, dut.clk, dut.rst)

  All signals must be passed separately into these classes.

  To send data into a design with an `MiiSource`, call `send()` or `send_nowait()`.  Accepted data types are iterables that can be converted to bytearray or `GmiiFrame` objects.  Optionally, call `wait()` to wait for the transmit operation to complete.  Example:

      await mii_source.send(GmiiFrame.from_payload(b'test data'))
      
      await mii_source.wait()

  It is also possible to wait for the transmission of a specific frame to complete by passing an event in the tx_complete field of the `GmiiFrame` object, and then awaiting the event.  The frame, with simulation time fields set, will be returned in the event data.  Example:

      frame = GmiiFrame.from_payload(b'test data', tx_complete=Event())
      await mii_source.send(frame)
      await frame.tx_complete.wait()
      print(frame.tx_complete.data.sim_time_sfd)

  To receive data with an `MiiSink`, call `recv()` or `recv_nowait()`.  Optionally call `wait()` to wait for new receive data.

      data = await mii_sink.recv()

  The `MiiPhy` class provides a model of an MII PHY chip.  It wraps instances of `MiiSource` (`rx`) and `MiiSink` (`tx`), provides the necessary clocking components, and provides the `set_speed()` method to change the link speed.  `set_speed()` changes the `tx_clk` and `rx_clk` frequencies.  In general, the `MiiPhy` class is intended to be used for integration tests where the design expects to be directly connected to an external MII PHY chip and contains all of the necessary IO and clocking logic.  Example:

      from cocotbext.eth import GmiiFrame, MiiPhy

      mii_phy = MiiPhy(dut.txd, dut.tx_er, dut.tx_en, dut.tx_clk,
          dut.rxd, dut.rx_er, dut.rx_en, dut.rx_clk, dut.rst, speed=100e6)

      mii_phy.set_speed(10e6)

      await mii_phy.rx.send(GmiiFrame.from_payload(b'test RX data'))
      tx_data = await mii_phy.tx.recv()



  * `txd`, `rxd`: data
  * `tx_er`, `rx_er`: error (when asserted with `tx_en` or `rx_dv`)
  * `tx_en`, `rx_dv`: data valid



  * _data_: data signal (txd, rxd, etc.)
  * _er_: error signal (tx_er, rx_er, etc.) (optional)
  * _dv_: data valid signal (tx_en, rx_dv, etc.)
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _enable_: clock enable (optional)
  * _reset_active_level_: reset active level (optional, default `True`)



  * _queue_occupancy_bytes_: number of bytes in queue
  * _queue_occupancy_frames_: number of frames in queue
  * _queue_occupancy_limit_bytes_: max number of bytes in queue allowed before backpressure is applied (source only)
  * _queue_occupancy_limit_frames_: max number of frames in queue allowed before backpressure is applied (source only)



  * `send(frame)`: send _frame_ (blocking) (source)
  * `send_nowait(frame)`: send _frame_ (non-blocking) (source)
  * `recv()`: receive a frame as a `GmiiFrame` (blocking) (sink)
  * `recv_nowait()`: receive a frame as a `GmiiFrame` (non-blocking) (sink)
  * `count()`: returns the number of items in the queue (all)
  * `empty()`: returns _True_ if the queue is empty (all)
  * `full()`: returns _True_ if the queue occupancy limits are met (source)
  * `idle()`: returns _True_ if no transfer is in progress (all) or if the queue is not empty (source)
  * `clear()`: drop all data in queue (all)
  * `wait()`: wait for idle (source)
  * `wait(timeout=0, timeout_unit='ns')`: wait for frame received (sink)



  Example transfer via MII at 100 Mbps:

                   _   _   _   _   _   _       _   _   _   _
      tx_clk     _/ \_/ \_/ \_/ \_/ \_/  ... _/ \_/ \_/ \_/ \_
                       ___ ___ ___ ___ _     _ ___ ___
      tx_d[3:0]  XXXXXX_5_X_5_X_5_X_5_X_ ... _X_f_X_b_XXXXXXXX

      tx_er      _______________________ ... _________________
                       _________________     _________
      tx_en      _____/                  ...          \_______




  The `RgmiiSource` and `RgmiiSink` classes can be used to drive, receive, and monitor RGMII traffic.  The `RgmiiSource` drives RGMII traffic into a design.  The `RgmiiSink` receives RGMII traffic, including monitoring internal interfaces.  The `RgmiiPhy` class is a wrapper around `RgmiiSource` and `RgmiiSink` that also provides clocking and rate-switching to emulate an RGMII PHY chip.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.eth import RgmiiSource, RgmiiSink

      rgmii_source = RgmiiSource(dut.rxd, dut.rx_ctl, dut.clk, dut.rst)
      rgmii_sink = RgmiiSink(dut.txd, dut.tx_ctl, dut.clk, dut.rst)

  All signals must be passed separately into these classes.

  To send data into a design with an `RgmiiSource`, call `send()` or `send_nowait()`.  Accepted data types are iterables that can be converted to bytearray or `GmiiFrame` objects.  Optionally, call `wait()` to wait for the transmit operation to complete.  Example:

      await rgmii_source.send(GmiiFrame.from_payload(b'test data'))
      
      await rgmii_source.wait()

  It is also possible to wait for the transmission of a specific frame to complete by passing an event in the tx_complete field of the `GmiiFrame` object, and then awaiting the event.  The frame, with simulation time fields set, will be returned in the event data.  Example:

      frame = GmiiFrame.from_payload(b'test data', tx_complete=Event())
      await rgmii_source.send(frame)
      await frame.tx_complete.wait()
      print(frame.tx_complete.data.sim_time_sfd)

  To receive data with an `RgmiiSink`, call `recv()` or `recv_nowait()`.  Optionally call `wait()` to wait for new receive data.

      data = await rgmii_sink.recv()

  The `RgmiiPhy` class provides a model of an RGMII PHY chip.  It wraps instances of `RgmiiSource` (`rx`) and `RgmiiSink` (`tx`), provides the necessary clocking components, and provides the `set_speed()` method to change the link speed.  `set_speed()` changes the `rx_clk` frequency and selects the appropriate mode (SDR or DDR) on the source and sink instances.  In general, the `RgmiiPhy` class is intended to be used for integration tests where the design expects to be directly connected to an external RGMII PHY chip and contains all of the necessary IO and clocking logic.  Example:

      from cocotbext.eth import GmiiFrame, RgmiiPhy

      rgmii_phy = RgmiiPhy(dut.txd, dut.tx_ctl, dut.tx_clk,
          dut.rxd, dut.rx_ctl, dut.rx_clk, dut.rst, speed=1000e6)

      rgmii_phy.set_speed(100e6)

      await rgmii_phy.rx.send(GmiiFrame.from_payload(b'test RX data'))
      tx_data = await rgmii_phy.tx.recv()



  * `txd`, `rxd`: data (DDR)
  * `tx_ctl`, `rx_ctl`: control (DDR, combination of valid and error)



  * _data_: data signal (txd, rxd, etc.)
  * _ctrl_: control
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _enable_: clock enable (optional)
  * _mii_select_: MII mode select (optional)
  * _reset_active_level_: reset active level (optional, default `True`)



  * _queue_occupancy_bytes_: number of bytes in queue
  * _queue_occupancy_frames_: number of frames in queue
  * _queue_occupancy_limit_bytes_: max number of bytes in queue allowed before backpressure is applied (source only)
  * _queue_occupancy_limit_frames_: max number of frames in queue allowed before backpressure is applied (source only)
  * _mii_mode_: control MII mode when _mii_select_ signal is not connected



  * `send(frame)`: send _frame_ (blocking) (source)
  * `send_nowait(frame)`: send _frame_ (non-blocking) (source)
  * `recv()`: receive a frame as a `GmiiFrame` (blocking) (sink)
  * `recv_nowait()`: receive a frame as a `GmiiFrame` (non-blocking) (sink)
  * `count()`: returns the number of items in the queue (all)
  * `empty()`: returns _True_ if the queue is empty (all)
  * `full()`: returns _True_ if the queue occupancy limits are met (source)
  * `idle()`: returns _True_ if no transfer is in progress (all) or if the queue is not empty (source)
  * `clear()`: drop all data in queue (all)
  * `wait()`: wait for idle (source)
  * `wait(timeout=0, timeout_unit='ns')`: wait for frame received (sink)



  Example transfer via RGMII at 1 Gbps:

                   ___     ___     ___     _       ___     ___
      tx_clk     _/   \___/   \___/   \___/  ... _/   \___/   \___
                         ___ ___ ___ ___ ___     ___ ___
      tx_d[3:0]  XXXXXXXX_5_X_5_X_5_X_5_X_5_ ... _f_X_b_XXXXXXXXXX
                         ___________________     _______
      tx_ctl     _______/                    ...        \_________




  The `XgmiiSource` and `XgmiiSink` classes can be used to drive, receive, and monitor XGMII traffic.  The `XgmiiSource` drives XGMII traffic into a design.  The `XgmiiSink` receives XGMII traffic, including monitoring internal interfaces.  The modules are capable of operating with XGMII interface widths of 32 or 64 bits.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.eth import XgmiiSource, XgmiiSink

      xgmii_source = XgmiiSource(dut.rxd, dut.rxc, dut.clk, dut.rst)
      xgmii_sink = XgmiiSink(dut.txd, dut.txc, dut.clk, dut.rst)

  All signals must be passed separately into these classes.

  To send data into a design with an `XgmiiSource`, call `send()` or `send_nowait()`.  Accepted data types are iterables that can be converted to bytearray or `XgmiiFrame` objects.  Optionally, call `wait()` to wait for the transmit operation to complete.  Example:

      await xgmii_source.send(XgmiiFrame.from_payload(b'test data'))
      
      await xgmii_source.wait()

  It is also possible to wait for the transmission of a specific frame to complete by passing an event in the tx_complete field of the `XgmiiFrame` object, and then awaiting the event.  The frame, with simulation time fields set, will be returned in the event data.  Example:

      frame = XgmiiFrame.from_payload(b'test data', tx_complete=Event())
      await xgmii_source.send(frame)
      await frame.tx_complete.wait()
      print(frame.tx_complete.data.sim_time_sfd)

  To receive data with an `XgmiiSink`, call `recv()` or `recv_nowait()`.  Optionally call `wait()` to wait for new receive data.

      data = await xgmii_sink.recv()



  * `txd`, `rxd`: data
  * `txc`, `rxc`: control



  * _data_: data signal (txd, rxd, etc.)
  * _ctrl_: control signal (txc, rxc, etc.)
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _enable_: clock enable (optional)
  * _reset_active_level_: reset active level (optional, default `True`)



  * _queue_occupancy_bytes_: number of bytes in queue
  * _queue_occupancy_frames_: number of frames in queue
  * _queue_occupancy_limit_bytes_: max number of bytes in queue allowed before backpressure is applied (source only)
  * _queue_occupancy_limit_frames_: max number of frames in queue allowed before backpressure is applied (source only)



  * `send(frame)`: send _frame_ (blocking) (source)
  * `send_nowait(frame)`: send _frame_ (non-blocking) (source)
  * `recv()`: receive a frame as an `XgmiiFrame` (blocking) (sink)
  * `recv_nowait()`: receive a frame as an `XgmiiFrame` (non-blocking) (sink)
  * `count()`: returns the number of items in the queue (all)
  * `empty()`: returns _True_ if the queue is empty (all)
  * `full()`: returns _True_ if the queue occupancy limits are met (source)
  * `idle()`: returns _True_ if no transfer is in progress (all) or if the queue is not empty (source)
  * `clear()`: drop all data in queue (all)
  * `wait()`: wait for idle (source)
  * `wait(timeout=0, timeout_unit='ns')`: wait for frame received (sink)



  Example transfer via 64-bit XGMII:

                    __    __    __    __    __    _       __    __
      tx_clk     __/  \__/  \__/  \__/  \__/  \__/  ... _/  \__/  \__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[63:56] __X_07__X_d5__X_51__X_01__X_09__X_ ... _X_fb__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[55:48] __X_07__X_55__X_5a__X_00__X_08__X_ ... _X_72__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[47:40] __X_07__X_55__X_d5__X_00__X_07__X_ ... _X_0d__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[39:32] __X_07__X_55__X_d4__X_80__X_06__X_ ... _X_37__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[31:24] __X_07__X_55__X_d3__X_55__X_05__X_ ... _X_2d__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[23:16] __X_07__X_55__X_d2__X_54__X_04__X_ ... _X_2c__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[15:8]  __X_07__X_55__X_d1__X_53__X_03__X_ ... _X_2b__X_07__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txd[7:0]   __X_07__X_fb__X_da__X_52__X_02__X_ ... _X_2a__X_fd__
                 __ _____ _____ _____ _____ _____ _     _ _____ _____
      txc[7:0]   __X_ff__X_01__X_00__X_00__X_00__X_ ... _X_00__X_ff__




  The `XgmiiFrame` object is a container for a frame to be transferred via XGMII.  The `data` field contains the packet data in the form of a list of bytes.  `ctrl` contains the control signal level state associated with each byte as a list of ints.  When `ctrl` is high, the corresponding `data` byte is interpreted as an XGMII control character.

  Attributes:

  * `data`: bytearray
  * `ctrl`: control field, optional; list, each entry qualifies the corresponding entry in `data` as an XGMII control character.
  * `sim_time_start`: simulation time of first transfer cycle of frame.
  * `sim_time_sfd`: simulation time at which the SFD was transferred.
  * `sim_time_end`: simulation time of last transfer cycle of frame.
  * `start_lane`: byte lane in which the start control character was transferred.
  * `tx_complete`: event or callable triggered when frame is transmitted.

  Methods:

  * `from_payload(payload, min_len=60)`: create `XgmiiFrame` from payload data, inserts preamble, zero-pads frame to minimum length and computes and inserts FCS (class method)
  * `from_raw_payload(payload)`: create `XgmiiFrame` from payload data, inserts preamble only (class method)
  * `get_preamble_len()`: locate SFD and return preamble length
  * `get_preamble()`: return preamble
  * `get_payload(strip_fcs=True)`: return payload, optionally strip FCS
  * `get_fcs()`: return FCS
  * `check_fcs()`: returns _True_ if FCS is correct
  * `normalize()`: pack `ctrl` to the same length as `data`, replicating last element if necessary, initialize to list of `0` if not specified.
  * `compact()`: remove `ctrl` if all zero



  The `EthMac`, `EthMacTx` and `EthMacRx` modules are models of an Ethernet MAC with an AXI stream interface.  The `EthMacRx` module drives Ethernet frames in the form of AXI stream traffic into a design.  The `EthMacTx` module accepts Ethernet frames in the form of AXI stream traffic from a design.  `EthMac` is a wrapper module containing `EthMacRx` (`rx`) and `EthMacTx` (`tx`).  The modules are capable of operating with any interface width.  The MAC models enforce the correct data rates and timings in both the receive and transmit direction, and can also collect PTP timestamps from a PTP hardware clock.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.axi import AxiStreamBus
      from cocotbext.eth import EthMac

      mac = EthMac(
          tx_clk=dut.tx_clk,
          tx_rst=dut.tx_rst,
          tx_bus=AxiStreamBus.from_prefix(dut, "tx_axis"),
          tx_ptp_time=dut.tx_ptp_time,
          tx_ptp_ts=dut.tx_ptp_ts,
          tx_ptp_ts_tag=dut.tx_ptp_ts_tag,
          tx_ptp_ts_valid=dut.tx_ptp_ts_valid,
          rx_clk=dut.rx_clk,
          rx_rst=dut.rx_rst,
          rx_bus=AxiStreamBus.from_prefix(dut, "rx_axis"),
          rx_ptp_time=dut.rx_ptp_time,
          ifg=12, speed=speed
      )

  To send data into a design, call `send()` or `send_nowait()`.  Accepted data types are iterables that can be converted to bytearray or `EthMacFrame` objects.  Optionally, call `wait()` to wait for the transmit operation to complete.  Example:

      await mac.tx.send(EthMacFrame.from_payload(b'test data'))
      
      await mac.tx.wait()

  It is also possible to wait for the transmission of a specific frame to complete by passing an event in the tx_complete field of the `EthMacFrame` object, and then awaiting the event.  The frame, with simulation time fields set, will be returned in the event data.  Example:

      frame = EthMacFrame.from_payload(b'test data', tx_complete=Event())
      await mac.tx.send(frame)
      await frame.tx_complete.wait()
      print(frame.tx_complete.data.sim_time_sfd)

  To receive data, call `recv()` or `recv_nowait()`.  Optionally call `wait()` to wait for new receive data.

      data = await mac.tx.recv()

  PTP timestamping requires free-running PTP clocks driving the PTP time inputs, synchronous with the corresponding MAC clocks.  The values of these fields are then captured when the frame SFD is transferred and returned either on tuser (for received frames) or on a separate streaming interface (for transmitted frames).  Additionally, on the transmit path, a tag value from tuser is returned along with the timestamp.



  * `tdata`: payload data, must be a multiple of 8 bits
  * `tvalid`: qualifies all other signals
  * `tready`: indicates sink is ready for data (tx only)
  * `tlast`: marks the last cycle of a frame
  * `tkeep`: qualifies data byte, data bus width must be evenly divisible by `tkeep` signal width
  * `tuser`: user data, carries frame error mark and captured receive PTP timestamp (RX) or PTP timestamp tag (TX)
  * `ptp_time`: PTP time input from PHC, captured into `ptp_timestamp` field coincident with transfer of frame SFD and output on `ptp_ts` (TX) or `tuser` (RX)
  * `ptp_ts`: captured transmit PTP timestamp
  * `ptp_ts_tag`: captured transmit PTP timestamp tag
  * `ptp_ts_valid`: qualifies captured transmit PTP timestamp



  * _bus_: `AxiStreamBus` object containing AXI stream interface signals
  * _clock_: clock signal
  * _reset_: reset signal (optional)
  * _ptp_time_: PTP time input from PHC (optional)
  * _ptp_ts_: PTP timestamp (optional) (tx)
  * _ptp_ts_tag_: PTP timestamp tag (optional) (tx)
  * _ptp_ts_valid_: PTP timestamp valid (optional) (tx)
  * _reset_active_level_: reset active level (optional, default `True`)
  * _ifg_: IFG size in byte times (optional, default `12`)
  * _speed_: link speed in bits per second (optional, default `1000e6`)



  * _tx_bus_: `AxiStreamBus` object containing transmit AXI stream interface signals
  * _tx_clk_: transmit clock
  * _tx_rst_: transmit reset (optional)
  * _tx_ptp_time_: transmit PTP time input from PHC (optional)
  * _tx_ptp_ts_: transmit PTP timestamp (optional)
  * _tx_ptp_ts_tag_: transmit PTP timestamp tag (optional)
  * _tx_ptp_ts_valid_: transmit PTP timestamp valid (optional)
  * _rx_bus_: `AxiStreamBus` object containing receive AXI stream interface signals
  * _rx_clk_: receive clock
  * _rx_rst_: receive reset (optional)
  * _rx_ptp_time_: receive PTP time input from PHC (optional)
  * _reset_active_level_: reset active level (optional, default `True`)
  * _ifg_: IFG size in byte times (optional, default `12`)
  * _speed_: link speed in bits per second (optional, default `1000e6`)



  * _queue_occupancy_bytes_: number of bytes in queue
  * _queue_occupancy_frames_: number of frames in queue
  * _queue_occupancy_limit_bytes_: max number of bytes in queue allowed before backpressure is applied (RX only)
  * _queue_occupancy_limit_frames_: max number of frames in queue allowed before backpressure is applied (RX only)
  * _ifg_: IFG size in byte times
  * _speed_: link speed in bits per second



  * `send(frame)`: send _frame_ (blocking) (rx)
  * `send_nowait(frame)`: send _frame_ (non-blocking) (rx)
  * `recv()`: receive a frame as an `EthMacFrame` (blocking) (tx)
  * `recv_nowait()`: receive a frame as an `EthMacFrame` (non-blocking) (tx)
  * `count()`: returns the number of items in the queue (all)
  * `empty()`: returns _True_ if the queue is empty (all)
  * `full()`: returns _True_ if the queue occupancy limits are met (rx)
  * `idle()`: returns _True_ if no transfer is in progress (all) or if the queue is not empty (rx)
  * `clear()`: drop all data in queue (all)
  * `wait()`: wait for idle (rx)
  * `wait(timeout=0, timeout_unit='ns')`: wait for frame received (tx)



  The `EthMacFrame` object is a container for a frame to be transferred via XGMII.  The `data` field contains the packet data in the form of a list of bytes.

  Attributes:

  * `data`: bytearray
  * `sim_time_start`: simulation time of first transfer cycle of frame.
  * `sim_time_sfd`: simulation time at which the SFD was transferred.
  * `sim_time_end`: simulation time of last transfer cycle of frame.
  * `ptp_tag`: PTP timestamp tag for transmitted frames.
  * `ptp_timestamp`: captured value of `ptp_time` at frame SFD
  * `tx_complete`: event or callable triggered when frame is transmitted.

  Methods:

  * `from_payload(payload, min_len=60)`: create `EthMacFrame` from payload data, zero-pads frame to minimum length and computes and inserts FCS (class method)
  * `from_raw_payload(payload)`: create `EthMacFrame` from payload data (class method)
  * `get_payload(strip_fcs=True)`: return payload, optionally strip FCS
  * `get_fcs()`: return FCS
  * `check_fcs()`: returns _True_ if FCS is correct



  The `PtpClock` class implements a PTP hardware clock that produces IEEE 1588 format 96-bit time-of-day and 64-bit relative PTP timestamps.

  To use this module, import it and connect it to the DUT:

      from cocotbext.eth import PtpClock

      ptp_clock = PtpClock(
          ts_tod=dut.ts_tod,
          ts_rel=dut.ts_rel,
          ts_step=dut.ts_step,
          pps=dut.pps,
          clock=dut.clk,
          reset=dut.reset,
          period_ns=6.4
      )

  Once the clock is instantiated, it will generate a continuous stream of monotonically increasing PTP timestamps on every clock edge.

  Internally, the `PtpClock` module uses 32-bit fractional ns fields for higher frequency resolution.  Only the upper 16 bits are returned in the timestamps, but the full fns value can be accessed with the _ts_tod_fns_ and _ts_rel_fns_ attributes.

  All APIs that handle fractional values use the `Decimal` type for maximum precision, as the combination of timestamp range and resolution is usually too much for normal floating point numbers to handle without significant loss of precision.



  * `ts_tod`: 96-bit time-of-day timestamp (48 bit seconds, 32 bit ns, 16 bit fractional ns)
  * `ts_rel`: 64-bit relative timestamp (48 bit ns, 16 bit fractional ns)
  * `ts_step`: step output, pulsed when non-monotonic step occurs
  * `pps`: pulse-per-second output, pulsed when ts_tod seconds field increments



  * _ts_tod_: 96-bit time-of-day timestamp signal (optional)
  * _ts_rel_: 64-bit relative timestamp signal (optional)
  * _ts_step_: timestamp step signal (optional)
  * _pps_: pulse-per-second signal (optional)
  * _clock_: clock
  * _reset_: reset (optional)
  * _reset_active_level_: reset active level (optional, default `True`)
  * _period_ns_: clock period (nanoseconds, default `6.4`)



  * _ts_tod_s_: current 96-bit ToD timestamp seconds field
  * _ts_tod_ns_: current 96-bit ToD timestamp ns field
  * _ts_tod_fns_: current 96-bit ToD timestamp fractional ns field
  * _ts_rel_ns_: current 64-bit relative timestamp ns field
  * _ts_rel_fns_: current 64-bit relative timestamp fractional ns field



  * `set_period(ns, fns)`: set clock period from separate fields
  * `set_drift(num, denom)`: set clock drift from separate fields
  * `set_period_ns(t)`: set clock period and drift in ns (Decimal)
  * `get_period_ns()`: return current clock period in ns (Decimal)
  * `set_ts_tod(ts_s, ts_ns, ts_fns)`: set 96-bit ToD timestamp from separate fields
  * `set_ts_tod_96(ts)`: set 96-bit ToD timestamp from integer
  * `set_ts_tod_ns(t)`: set 96-bit ToD timestamp from ns (Decimal)
  * `set_ts_tod_s(t)`: set 96-bit ToD timestamp from seconds (Decimal)
  * `set_ts_tod_sim_time()`: set 96-bit ToD timestamp from sim time
  * `get_ts_tod()`: return current 96-bit ToD timestamp as separate fields
  * `get_ts_tod_96()`: return current 96-bit ToD timestamp as an integer
  * `get_ts_tod_ns()`: return current 96-bit ToD timestamp in ns (Decimal)
  * `get_ts_tod_s()`: return current 96-bit ToD timestamp in seconds (Decimal)
  * `set_ts_rel(ts_ns, ts_fns)`: set 64-bit relative timestamp from separate fields
  * `set_ts_rel_64(ts)`: set 64-bit relative timestamp from integer
  * `set_ts_rel_ns(t)`: set 64-bit relative timestamp from ns (Decimal)
  * `set_ts_rel_s(t)`: set 64-bit relative timestamp from seconds (Decimal)
  * `set_ts_rel_sim_time()`: set 64-bit relative timestamp from sim time
  * `get_ts_rel()`: return current 64-bit relative timestamp as separate fields
  * `get_ts_rel_64()`: return current 64-bit relative timestamp as an integer
  * `get_ts_rel_ns()`: return current 64-bit relative timestamp in ns (Decimal)
  * `get_ts_rel_s()`: return current 64-bit relative timestamp in seconds (Decimal)



  The `PtpClockSimTime` class implements a PTP hardware clock that produces IEEE 1588 format 96-bit time-of-day and 64-bit relative PTP timestamps, derived from the current simulation time.  This module can be used in place of `PtpClock` so that captured PTP timestamps can be easily compared to captured simulation time.

  To use this module, import it and connect it to the DUT:

      from cocotbext.eth import PtpClockSimTime

      ptp_clock = PtpClockSimTime(
          ts_tod=dut.ts_tod,
          ts_rel=dut.ts_rel,
          pps=dut.pps,
          clock=dut.clk
      )

  Once the clock is instantiated, it will generate a continuous stream of monotonically increasing PTP timestamps on every clock edge.

  All APIs that handle fractional values use the `Decimal` type for maximum precision, as the combination of timestamp range and resolution is usually too much for normal floating point numbers to handle without significant loss of precision.



  * `ts_tod`: 96-bit time-of-day timestamp (48 bit seconds, 32 bit ns, 16 bit fractional ns)
  * `ts_rel`: 64-bit relative timestamp (48 bit ns, 16 bit fractional ns)
  * `pps`: pulse-per-second output, pulsed when ts_tod seconds field increments



  * _ts_tod_: 96-bit time-of-day timestamp signal (optional)
  * _ts_rel_: 64-bit relative timestamp signal (optional)
  * _pps_: pulse-per-second signal (optional)
  * _clock_: clock



  * _ts_tod_s_: current 96-bit ToD timestamp seconds field
  * _ts_tod_ns_: current 96-bit ToD timestamp ns field
  * _ts_tod_fns_: current 96-bit ToD timestamp fractional ns field
  * _ts_rel_ns_: current 64-bit relative timestamp ns field
  * _ts_rel_fns_: current 64-bit relative timestamp fractional ns field



  * `get_ts_tod()`: return current 96-bit ToD timestamp as separate fields
  * `get_ts_tod_96()`: return current 96-bit ToD timestamp as an integer
  * `get_ts_tod_ns()`: return current 96-bit ToD timestamp in ns (Decimal)
  * `get_ts_tod_s()`: return current 96-bit ToD timestamp in seconds (Decimal)
  * `get_ts_rel()`: return current 64-bit relative timestamp as separate fields
  * `get_ts_rel_96()`: return current 64-bit relative timestamp as an integer
  * `get_ts_rel_ns()`: return current 64-bit relative timestamp in ns (Decimal)
  * `get_ts_rel_s()`: return current 64-bit relative timestamp in seconds (Decimal)


pkgId: a09e01587df7490667e711524aa40200834bcb7ae1b7c696aaa99be8f81f2c84
name: python-cocotbext-jtag
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: jtag modules for cocotb
url: https://github.com/daxzio/cocotbext-jtag
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotbext-jtag-0.0.11-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/daxzio/cocotbext-jtag/workflows/Regression%20Tests/badge.svg?branch=main)](https://github.com/daxzio/cocotbext-jtag/actions/)
  [![codecov](https://codecov.io/gh/daxzio/cocotbext-jtag/branch/main/graph/badge.svg)](https://codecov.io/gh/daxzio/cocotbext-jtag)
  [![PyPI version](https://badge.fury.io/py/cocotbext-jtag.svg)](https://pypi.org/project/cocotbext-jtag)
  [![Downloads](https://pepy.tech/badge/cocotbext-jtag)](https://pepy.tech/project/cocotbext-jtag)

  GitHub repository: https://github.com/daxzio/cocotbext-jtag



  JTAG simulation models for [cocotb](https://github.com/cocotb/cocotb).



  Installation from pip (release version, stable):

      $ pip install cocotbext-jtag

  Installation from git (latest development version, potentially unstable):

      $ pip install https://github.com/daxzio/cocotbext-jtag/archive/main.zip

  Installation for active development:

      $ git clone https://github.com/daxzio/cocotbext-jtag
      $ pip install -e cocotbext-jtag



  See the `tests` directory for complete testbenches using these modules.



  The `JTAGBus` is used to map to a JTAG interface on the `dut`.  These hold instances of bus objects for the individual channels, which are currently extensions of `cocotb_bus.bus.Bus`.  Class methods `from_entity` and `from_prefix` are provided to facilitate signal default name matching.


  * _tck_
  * _tms_
  * _tdi_
  * _tdo_


  * _trst_



  The `JTAGDriver` class implement a JTAG driver and is capable of generating read and write operations against JTAG devices, either singularly or in a chain.

  To use these modules, import the one you need and connect it to the DUT:

      from cocotbext.jtag import JTAGDriver, JTAGBus, JTAGDevice

      bus = JTAGBus(dut)
      jtag_driver = JTAGDriver(bus)
      jtag_driver.add_device(JTAGDevice())

  The first argument to the constructor accepts an `JTAGBus` object.  These objects are containers for the interface signals and include class methods to automate connections.

  Once the module is instantiated, read and write operations can be initiated in a couple of different ways.




  * _period_: Clock frequency period of `tck`, default `100`
  * _units_: Clock units, default `ns`
  * _logging_enabled_: Logging enable, default `True`




  * `add_device(device)`: Add device to jtag chain, must be of type `JTAGDevice`
  * `set_reset(num)`: Reset for _num_ if _trst_ is present in `JTAGBus`, raise warning if _trst_ is not present
  * `reset_finished()`: Asyn wait until reset is finished
  * `reset_fsm()`: Send 5 _tck_ pulses while _tms_ is held high in `JTAGBus`, this resets the finite state machine inside a JTAG TAP
  * `send_val(addr, val, device, write)`: Send _addr_ to _device_ (default: `0`). The _val_ is used to write if _write_ is True or verify against if _write_ is False
  * `write_val(addr, val, device=0)`: Write _val_ to _addr_ of _device_ (default: `0`).
  * `read_val(addr, val=None, device=0)`: Read from _addr_ of _device_ (default: `0`). If _val_ present verify against returned value.
  * `read_idcode(device)`: Read device number _device_ and confirm it matched the IDCODE set for that device




  `JTAGDriver` needs to be told what devices are in the JTAG chain it is communicating with inside the `dut`. A `JTAGDevice` needs to be defined for this purpose or a device that inherits from this base class.

  A `JTAGDevice` needs a _name_, _idcode_ and _ir_len_.  It also seens to have the IR Register map defined and the width of the the register.  'BYPASS' is prepopulated in the base class at last address in the IRLEN address map.

  First inherit from the base class, , and after add all the other IR regiters using the _add_jtag_reg_ method.


      from cocotbext.jtag import JTAGDevice

      class J1JTAGDevice(JTAGDevice):
          def __init__(self, name='jtaglet1', idcode=0x53817905, ir_len=5):
              super().__init__(name, idcode, ir_len)
              self.add_jtag_reg("IDCODE", 32, 0x1e)
              self.add_jtag_reg('USERDATA', 32, 0x8)
              self.add_jtag_reg('USEROP', 8, 0x9)
              self.idle_delay = 6

  * `add_jtag_reg(name, width, address)`: Add an IR register to `JTAGDevice`. _name_ is a string, _width_ is the DR shift width of the register and the address, which should be with in the range if the _ir_len_ of `JTAGDevice`


  This results in a `JTAGDevice` that has 4 IR register defined:


      0x08: USERDATA[31:0]
      0x09: USEROP[7:0]
      0x1e: IDCODE[31:0]
      0x1f: BYPASS[0:0]


  Multiple devices inside the JTAG chain:

      from cocotbext.jtag import JTAGDriver
      from cocotbext.jtag import JTAGBus

      class testbench:
          def __init__(self, dut):
              bus = JTAGBus(dut)
              self.jtag = JTAGDriver(bus)
              self.jtag.add_device(J1JTAGDevice())
              self.jtag.add_device(J2JTAGDevice())


pkgId: ac584858fa6a98bc94f97703b5894df0d831bf606f3bd72722c58e8606d8654c
name: python-cocotbext-pcie
arch: src
version: 0.2.14
epoch: 0
release: 1
summary: PCI express simulation framework for cocotb
url: https://github.com/alexforencich/cocotbext-pcie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotbext-pcie-0.2.14-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/alexforencich/cocotbext-pcie/workflows/Regression%20Tests/badge.svg?branch=master)](https://github.com/alexforencich/cocotbext-pcie/actions/)
  [![codecov](https://codecov.io/gh/alexforencich/cocotbext-pcie/branch/master/graph/badge.svg)](https://codecov.io/gh/alexforencich/cocotbext-pcie)
  [![PyPI version](https://badge.fury.io/py/cocotbext-pcie.svg)](https://pypi.org/project/cocotbext-pcie)
  [![Downloads](https://pepy.tech/badge/cocotbext-pcie)](https://pepy.tech/project/cocotbext-pcie)

  GitHub repository: https://github.com/alexforencich/cocotbext-pcie



  PCI express simulation framework for [cocotb](https://github.com/cocotb/cocotb).



  Installation from pip (release version, stable):

      $ pip install cocotbext-pcie

  Installation from git (latest development version, potentially unstable):

      $ pip install https://github.com/alexforencich/cocotbext-pcie/archive/master.zip

  Installation for active development:

      $ git clone https://github.com/alexforencich/cocotbext-pcie
      $ pip install -e cocotbext-pcie



  See the `tests` directory, [verilog-pcie](https://github.com/alexforencich/verilog-pcie), and [corundum](https://github.com/corundum/corundum) for complete testbenches using these modules.



  The core PCIe simulation framework is included in `cocotbext.pcie.core`.  This framework implements an extensive event driven simulation of a complete PCI express system, including root complex, switches, devices, and functions, including support for configuration spaces, capabilities and extended capabilities, and memory and IO operations between devices.  The framework includes code to enumerate the bus, initialize configuration space registers and allocate BARs, route messages between devices, perform memory read and write operations, allocate DMA accessible memory regions in the root complex, and handle message signaled interrupts.  Any module can be connected to a cosimulated design, enabling testing of not only isolated components and host-device communication but also communication between multiple components such as device-to-device DMA and message passing.





  Models of the Xilinx UltraScale and UltraScale+ PCIe hard cores are included in `cocotbext.pcie.xilinx.us`.  These modules can be used in combination with the PCIe BFM to test an HDL design that targets Xilinx UltraScale, UltraScale+, or Virtex 7 series FPGAs, up to PCIe gen 3 x16 or PCIe gen 4 x8.  The models currently only support operation as a device, not as a root port.



  Models of the Intel Stratix 10 H-Tile/L-Tile PCIe hard cores are included in `cocotbext.pcie.intel.s10`.  These modules can be used in combination with the PCIe BFM to test an HDL design that targets Intel Stratix 10 GX, SX, TX, and MX series FPGAs that contain H-Tiles or L-Tiles, up to PCIe gen 3 x16.  The models currently only support operation as a device, not as a root port.



  Models of the Intel P-Tile PCIe hard cores are included in `cocotbext.pcie.intel.ptile`.  These modules can be used in combination with the PCIe BFM to test an HDL design that targets Intel Stratix 10 DX or Agilex F series FPGAs that contain P-Tiles, up to PCIe gen 4 x16.  The models currently only support operation as a device, not as a root port.


pkgId: f6a7c071b833077da3b1ea535a1cf3303436e2062edde31028bf61f15686e7c8
name: python-cocotbext-spi
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: SPI modules for cocotb
url: https://pypi.org/project/cocotbext-spi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cocotbext-spi-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Regression Tests](https://github.com/schang412/cocotbext-spi/actions/workflows/regression-tests.yml/badge.svg)](https://github.com/schang412/cocotbext-spi/actions/workflows/regression-tests.yml)
  [![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)

  GitHub repository: https://github.com/schang412/cocotbext-spi



  SPI simulation framework for [cocotb](https://github.com/cocotb/cocotb).



  Installation from pip (release version, stable):

  ```bash
  pip install cocotbext-spi
  ```

  Installation from git (latest development version, potentially unstable):

  ```bash
  pip install https://github.com/schang412/cocotbext-spi/archive/main.zip
  ```

  Installation for active development:

  ```bash
  git clone https://github.com/schang412/cocotbext-spi
  pip install -e cocotbext-spi
  ```



  See the `tests` directory for complete testbenches using these modules.



  The SPI bus signals are bundled together into a `SpiBus` class.

  If the port instantiations look like:

  ```verilog
  module my_module(
      input  wire sclk,
      input  wire mosi,
      output wire miso,
      input  wire cs,  // active-low
  )

  ```
  The `SpiBus` class can be created as:

  ```python
  from cocotbext.spi import SpiBus
  spi_bus = SpiBus.from_entity(dut)
  ```

  If there is some prefix, the `from_prefix` class method may be used:

  ```verilog
  module my_module(
      input  wire spi0_sclk,
      input  wire spi0_mosi,
      output wire spi0_miso,
      input  wire spi0_cs,  // active-low
  )
  ```

  ```python
  spi_bus = SpiBus.from_prefix(dut, "spi0")
  ```

  If some signals have been renamed for clarity:

  ```verilog
  module my_module(
      input  wire spi0__sck,
      input  wire spi0__mosi,
      output wire spi0__miso,
      input  wire spi0__ncs,  // active-low
  )
  ```

  ```python
  spi_bus = SpiBus.from_prefix(dut, "spi0", bus_separator="__", sclk_name="sck", cs_name="ncs")
  ```



  SPI Configuration parameters are bundled together into a `SpiConfig` class.

  To create the object simply call it like a class and pass in arguments:

  ```python
  from cocotbext.spi import SpiConfig

  spi_config = SpiConfig(
      word_width = 16,        # number of bits in a SPI transaction
      sclk_freq  = 25e6,      # clock rate in Hz
      cpol       = False,     # clock idle polarity
      cpha       = True,      # clock phase (CPHA=True means data sampled on second edge)
      msb_first  = True,      # the order that bits are clocked onto the wire
      data_output_idle = 1,   # the idle value of the MOSI or MISO line
      frame_spacing_ns = 1,   # the spacing between frames that the master waits for or the slave obeys
                              
      ignore_rx_value = None, # MISO value that should be ignored when received
      cs_active_low = True    # the chip select is active low
  )
  ```

  All parameters are optional, and the defaults are shown above.



  The `SpiMaster` class acts as an SPI Master endpoint.

  To use this class, import it, configure it, and connect to the dut.

  ```python
  from cocotbext.spi import SpiMaster, SpiBus, SpiConfig

  spi_bus = SpiBus.from_entity(dut)

  spi_config = SpiConfig(
      word_width = 16,     # all parameters optional
      sclk_freq  = 25e6,   # these are the defaults
      cpol       = False,
      cpha       = True,
      msb_first  = True,
      cs_active_low = True # optional (assumed True)
  )

  spi_master = SpiMaster(spi_bus, spi_config)
  ```

  To send data into a design with `SpiMaster`, call `write()` or `write_nowait()`. Accepted data types are iterables of ints including lists, bytes, bytearrays, etc. Optionally, call wait() to wait for the transmit operation to complete. We can take a look at the data received back with `read()` or `read_nowait()`

  ```python

  spi_master.write_nowait([0xFFFF])
  await spi_master.wait()
  read_bytes = await spi_master.read()
  print(read_bytes)


  await spi_master.write([0xFFFF])
  read_bytes = await spi_masetr.read()
  ```



  - `bus`: SpiBus
  - `config`: SpiConfig



  - `write(data)`: send data (blocking)
  - `write_nowait(data)`: send data (non-blocking)
  - `read(count=-1)`: read count bytes from buffer, reading whole buffer by default (blocking)
  - `read_nowait(count=-1)`: read count bytes from buffer, reading whole buffer by default (non-blocking)
  - `count_tx()`: returns the number of items in the transmit queue
  - `count_rx()`: returns the number of items in the receive queue
  - `empty_tx()`: returns True if the transmit queue is empty
  - `empty_rx()`: returns True if the receive queue is empty
  - `idle()`: returns True if the transmit and receive buffers are empty
  - `clear()`: drop all data in the queue



  The `SpiSlaveBase` acts as an abstract class for a SPI Slave Endpoint.

  To use this class, import it and inherit it. Then use the subclass as the slave and connect it to the dut.

  ```python
  from cocotbext.spi import SpiMaster, SpiBus, SpiConfig

  class SimpleSpiSlave(SpiSlaveBase):
      def __init__(self, bus):
          self._config = SpiConfig()
          self.content = 0
          super().__init__(bus)

      async def get_content(self):
          await self.idle.wait()
          return self.content

      async def _transaction(self, frame_start, frame_end):
          await frame_start
          self.idle.clear()

          self.content = int(await self._shift(16, tx_word=(0xAAAA)))

          await frame_end

  spi_slave = SimpleSpiSlave(SpiBus.from_entity(dut))
  ```



  All SPI Slave Classes should:

  - inherit the SpiSlaveBase class
  - define `self._config` adjust the values for:
      - `word_width`
      - `cpha`
      - `cpol`
      - `msb_first`
      - `frame_spacing_ns`
  - implement a `_transaction` coroutine
      - the coroutine should take 3 arguments, self, frame_start and frame_end
      - the coroutine should await frame_start at the transaction start, and frame_end when done.
          - frame_start and frame_end are Rising and Falling edges of the chip select based on the chip select polarity
      - when the coroutine receives a frame_start signal, it should clear the `self.idle` Event.
          - `self.idle` is automatically set when `_transaction` returns
  - when implementing a method to read the class contents, make sure to await the `self.idle`, otherwise the data may not be up to date because the device is in the middle of a transaction.



  This framework includes some SPI Slave devices built in. A list of supported devices can be found in `cocotbext/spi/devices` and are sorted by vendor.

  To use these devices, you can simply import them.

  ```python
  from cocotbext.spi.devices.TI import DRV8306

  spi_slave = DRV8306(SpiBus.from_entity(dut, cs_name="ncs"))
  ```

  To submit a new device, make a pull request.


pkgId: d718a193a2ce6f07fe73b3c2e82d747f6d51957f8fa95655de4c27aead1d80aa
name: python-codaio
arch: src
version: 0.6.12
epoch: 0
release: 1
summary: Python wrapper for Coda.io API
url: https://github.com/Blasterai/codaio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codaio-0.6.12-1.src.rpm
checksum_type: sha256
description:
  [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner-direct.svg)](https://vshymanskyy.github.io/StandWithUkraine)



  [![CodaAPI](https://img.shields.io/badge/Coda_API_-V1-green)](https://coda.io/developers/apis/v1beta1)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/codaio)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Documentation Status](https://readthedocs.org/projects/codaio/badge/?version=latest)](https://codaio.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/codaio)](https://pypi.org/project/codaio/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/codaio)
  [![](https://img.shields.io/badge/Support-Buy_coffee!-Orange)](https://www.buymeacoffee.com/licht1stein)

  Don't hesitate to contribute, issues and PRs very welcome!



  Install with [poetry](https://python-poetry.org/) (always recommended):

  ```shell script
  poetry add codaio
  ```

  or with `pip`

  ```shell script
  pip install codaio
  ```


  The following variables will be called from environment where applicable:

  * `CODA_API_ENDPOINT` (default value `https://coda.io/apis/v1`)
  * `CODA_API_KEY` - your API key to use when initializing client from environment


  Coda class provides a wrapper for all API methods. If API response included a JSON it will be returned as a dictionary from all methods. If it didn't a dictionary `{"status": response.status_code}` will be returned.
  If request wasn't successful a `CodaError` will be raised with details of the API error.

  ```python
  from codaio import Coda

  coda = Coda('YOUR_API_KEY')

  >>> coda.create_doc('My Document')
  {'id': 'NEW_DOC_ID', 'type': 'doc', 'href': 'https://coda.io/apis/v1/docs/NEW_DOC_ID', 'browserLink': 'https://coda.io/d/_dNEW_DOC_ID', 'name': 'My Document', 'owner': 'your@email', 'ownerName': 'Your Name', 'createdAt': '2020-09-28T19:32:20.866Z', 'updatedAt': '2020-09-28T19:32:20.924Z'}
  ```
  For full API reference for Coda class see [documentation](https://codaio.readthedocs.io/en/latest/index.html#codaio.Coda)



  `codaio` implements convenient classes to work with Coda documents: `Document`, `Table`, `Row`, `Column` and `Cell`.

  ```python
  from codaio import Coda, Document


  coda = Coda('YOUR_API_KEY')

  doc = Document('YOUR_DOC_ID', coda=coda)


  doc = Document.from_environment('YOUR_DOC_ID')

  doc.list_tables()

  table = doc.get_table('TABLE_ID')
  ```

  ```python

  row  = table['ROW_ID']
  ```


  If you want to load a codaio Table or Row into pandas, you can use the `Table.to_dict()` or `Row.to_dict()` methods:
  ```python
  import pandas as pd

  df = pd.DataFrame(table.to_dict())
  ```


  ```python

  cell = table['ROW_ID']['COLUMN_ID']


  cell = row['COLUMN_ID']

  cell = row['COLUMN_NAME']  # This should work fine if COLUMN_NAME is unique, otherwise it will raise AmbiguousColumn error

  cell = row[column]
  ```



  ```python
  row['COLUMN_ID'] = 'foo'

  row['Column Name'] = 'foo'
  ```


  ```python

  for row in table.rows():
      if row['COLUMN_ID'] == 'foo':
          row.delete()


  for row in table.rows():
      if row['Name'] == 'bar':
          row['Value'] = 'spam'
  ```


  To upsert a new row you can pass a list of cells to `table.upsert_row()`
  ```python
  name_cell = Cell(column='COLUMN_ID', value_storage='new_name')
  value_cell = Cell(column='COLUMN_ID', value_storage='new_value')

  table.upsert_row([name_cell, value_cell])
  ```


  Works like upserting one row, except you pass a list of lists to `table.upsert_rows()` (rows, not row)
  ```python
  name_cell_a = Cell(column='COLUMN_ID', value_storage='new_name')
  value_cell_a = Cell(column='COLUMN_ID', value_storage='new_value')

  name_cell_b = Cell(column='COLUMN_ID', value_storage='new_name')
  value_cell_b = Cell(column='COLUMN_ID', value_storage='new_value')

  table.upsert_rows([[name_cell_a, value_cell_a], [name_cell_b, value_cell_b]])
  ```


  To update a row use `table.update_row(row, cells)`
  ```python
  row = table['ROW_ID']

  name_cell_a = Cell(column='COLUMN_ID', value_storage='new_name')
  value_cell_a = Cell(column='COLUMN_ID', value_storage='new_value')

  table.update_row(row, [name_cell_a, value_cell_a])
  ```



  `codaio` documentation lives at [readthedocs.io](https://codaio.readthedocs.io/en/latest/index.html)



  The recommended way of running the test suite is to use [nox](https://nox.thea.codes/en/stable/tutorial.html).

  Once `nox`: is installed, just run the following command:
  ```shell script
  nox
  ```

  The nox session will run the test suite against python 3.8 and 3.7. It will also look for linting errors with `flake8`.

  You can still invoke `pytest` directly with:
  ```shell script
  poetry run pytest --cov
  ```

  Check out the fixtures if you want to improve the testing process.




  If you are willing to contribute please go ahead, we can use some help!



  When a PR is merged to master the CI will try to deploy to pypi.org using poetry. It will succeed only if the
  version number changed in pyproject.toml.

  To do so use poetry's [version command](https://python-poetry.org/docs/cli/#version). For example:

  Bump 0.4.11 to 0.4.12:
  ```bash
  poetry version patch
  ```

  Bump 0.4.11 to 0.5.0:
  ```bash
  poetry version minor
  ```

  Bump 0.4.11 to 1.0.0:
  ```bash
  poetry version major
  ```


pkgId: b0d12a6d7ce20204fa886ca29d36c372f84e9c73b72bc962f8aa14fd90227531
name: python-codal-tsetmc
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Data Downloader for Codal and Tehran stock market
url: https://mohsenebrahimyir.github.io/codal-tsetmc/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codal-tsetmc-1.6.1-1.src.rpm
checksum_type: sha256
description:
  این پکیچ برای ذخیره داده‌های سایت کدال و بازار سرمایه برای اهداف تحلیل بنیادی تهیه شده است.

  - [آموزش بسته](https://mohsenebrahimyir.github.io/codal-tsetmc/)
  - [تلگرام @codal_tsetmc_package](https://t.me/codal_tsetmc_package)
  - [ایتا @codal_tsetmc_package](https://eitaa.com/codal_tsetmc_package)



  اگر این متن را میبینید یعنی این پکیج درحال توسعه است و قابلیت استفاده در پروژه‌های مهم را ندارد.

  ```bash

  python3 -m build
  ```

  ```bash

  python3 -m twine upload --repository pypi dist/*
  ```





  - [X] `tehran_stocks`: الهام از بسته
  - [X] `stock`: لیست تمام سهام‌ها و صندوق‌ها و ...
  - [X] `stock_capital`: پایگاه داده افزایش سرمایه
    - باید دقت کنیم که بعضی از افزایش سرمایه‌‌های سایت tsetmc بروز نیست و باید برای محاسبه مقدار دقیق از صورت‌های مالی شرکت‌ها استفاده کرد.
  - [X] `stock_price`: قیمت و حجم معاملات روزانه
  - [X] `stock_group`:


  - [X] `company`: لیست تمام شرکت‌ها
  - [X] `company_state`: وضعیت شرکت‌ها
  - [X] `company_type`: نوع شرکت‌ها
  - [X] `report_type`: گروه اطلاعیه‌ها
  - [X] `letter_type`: نوع گزارش
  - [X] `auditor`: حسابرس‌ها
  - [X] `financial_year`: سال مالی‌ها
  - [X] `letter`: گزارشات مالی



  برای استفاده از این بسته پیشنهاد می‌شود از محیط مجازی استفاده کنید.

  ```bash
  python -m venv .venv
  ```

  فعال سازی محیط مجازی در لینوکس

  ```bash
  source .venv/bin/activate
  ```

  فعال سازی محیط مجازی در ویندوز

  ```cmd
  > .\venv\Scripts\activate
  ```

  نصب از `pypi`:

  ```bash
  pip install -U codal-tsetmc
  ```

  نصب از نسخه در حال توسعه `github`

  ```bash
  pip install git+https://github.com/mohsenebrahimyir/codal-tsetmc.git
  ```


pkgId: 0cf1c97aa13158d03aa6dba4c35c1040cfb3b9b31fd29a8d539577ba5d35cc0e
name: python-codalab
arch: src
version: 1.7.5
epoch: 0
release: 1
summary: CLI for CodaLab, a platform for reproducible computation
url: https://github.com/codalab/codalab-worksheets
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codalab-1.7.5-1.src.rpm
checksum_type: sha256
description:
  Visit https://worksheets.codalab.org/ or setup your own server by following the instructions in the documentation (https://codalab-worksheets.readthedocs.io/en/latest/Server-Setup).


pkgId: 74768e15245458acfd5ec1b774d437dccad92696a581cbda7f510ffc24fe3ba5
name: python-codapy
arch: src
version: 0.3.28
epoch: 0
release: 1
summary: Coded statement of Account (CODA) python API
url: https://github.com/mhemeryck/pycoda
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codapy-0.3.28-1.src.rpm
checksum_type: sha256
description:
  [![CI status](https://github.com/mhemeryck/pycoda/actions/workflows/main.yaml/badge.svg)](https://github.com/mhemeryck/pycoda/actions/workflows/main.yaml)
  [![Coverage Status](https://coveralls.io/repos/github/mhemeryck/pycoda/badge.svg)](https://coveralls.io/github/mhemeryck/pycoda)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
  [![PyPI version](https://badge.fury.io/py/codapy.svg)](https://badge.fury.io/py/codapy)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  Generate a CODA file from a factory:
  ```python
  >>> from pycoda.factories import CodaFileFactory
  >>> coda_file = CodaFileFactory()
  >>> print coda_file.dumps()
  0000029050288805        TWlscjlKSUAnthony Hicks             GKCCBEBB   06141120086                                             2
  10000                                     0000000026785942011208                                                             000
  2121170000                     0000000700448471091015000000000                                                     15030900000 0
  8000                                     0000000000000000160417                                                                0
  9               134803000000336605556000000724123462                                                                           2
  ```

  Check the values of the first record:
  ```python
  >>> coda_file.records[0].field_dict()
  {'account_holder_reference': 61411200863,
   'addressee': u'Anthony Hicks',
   'application_code': u'05',
   'bank_identification_number': 888,
   'bic': u'GKCCBEBB',
   'creation_date': datetime.date(2002, 5, 29),
   'duplicate': False,
   'empty': None,
   'free': None,
   'identification': 0,
   'reference': u'TWlscjlKSU',
   'related_reference': None,
   'transaction_reference': None,
   'version_code': 2,
   'zeroes': None}
  ```

  Update a named field of the first record:
  ```python
  >>> coda_file.records[0].addressee = u'John Doe'
  >>> print coda_file.records[0].dumps()
  0000029050288805        TWlscjlKSUJohn Doe                  GKCCBEBB   06141120086                                             2
  ```

  Make a new CODA file object and load the records / fields from the previous object string representation:
  ```python
  >>> plain = coda_file.dumps()
  >>> from pycoda.codafile import CodaFile
  >>> new_coda = CodaFile()
  >>> new_coda.loads(plain)
  >>> print new_coda.dumps()
  0000029050288805        TWlscjlKSUJohn Doe                  GKCCBEBB   06141120086                                             2
  10000                                     0000000026785942011208                                                             000
  2121170000                     0000000700448471091015000000000                                                     15030900000 0
  8000                                     0000000000000000160417                                                                0
  9               134803000000336605556000000724123462                                                                           2
  >>> new_coda.dumps() == coda_file.dumps()
  True
  ```



  The following model hierarchy is employed:
    * CODA file: can consist of multiple records of given type
    * Record type: each of the record types hold different specified named fields of given type
    * Field type: the fields hold the actual values. All the parsing / printing footwork is done at this level

  For each of those levels, the objects can:
    * loads: set value from string representation
    * dumps: generate string representation from value


pkgId: 26f5f315e5a7821d613e9d996c6736ac83699f67c1ec9792665108ab1d9237fd
name: python-codat-accounting
arch: src
version: 0.36.0
epoch: 0
release: 1
summary: Access standardized accounting data from our accounting integrations.
url: https://github.com/codatio/client-sdk-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codat-accounting-0.36.0-1.src.rpm
checksum_type: sha256
description:
  <!-- Start Codat Library Description -->
  ﻿Codat's Accounting API is a flexible API for pulling and pushing up-to-date accounting data to your customer's accounting software.
  It gives you a simple way to view, create, update adn delete data without having to worry about each platform's specific complexities.

  <!-- End Codat Library Description -->


  <!-- Start Summary [summary] -->


  Accounting API: > ### New to Codat?
  >
  > Our Accounting API reference is relevant only to our existing clients.
  > Please reach out to your Codat contact so that we can find the right product for you.

  A flexible API for pulling accounting data, normalized and aggregated from 20 accounting integrations.

  Standardize how you connect to your customers’ accounting software. View, create, update, and delete data in the same way for all the leading accounting software.

  <!-- Start Codat Tags Table -->


  | Endpoints | Description |
  | :- |:- |
  | Accounts | Access standardized Accounts from linked accounting software. |
  | Account transactions | Access standardized Account transactions from linked accounting software. |
  | Bank accounts | Access standardized Bank accounts from linked accounting software. |
  | Bank account transactions | Access standardized Bank transactions for bank accounts from linked accounting software. |
  | Bills | Access standardized Bills from linked accounting software. |
  | Bill credit notes | Access standardized Bill credit notes from linked accounting software. |
  | Bill payments | Access standardized Bill payments from linked accounting software. |
  | Credit notes | Access standardized Credit notes from linked accounting software. |
  | Customers | Access standardized Customers from linked accounting software. |
  | Direct costs | Access standardized Direct costs from linked accounting software. |
  | Direct incomes | Access standardized Direct incomes from linked accounting software. |
  | Company info | Access standardized Company info from linked accounting software. |
  | Invoices | Access standardized Invoices from linked accounting software. |
  | Item receipts | Access standardized Item receipts from linked accounting software. |
  | Items | Access standardized Items from linked accounting software. |
  | Journals | Access standardized Journals from linked accounting software. |
  | Journal entries | Access standardized Journal entries from linked accounting software. |
  | Payments | Access standardized Payments from linked accounting software. |
  | Payment methods | Access standardized Payment methods from linked accounting software. |
  | Purchase orders | Access standardized Purchase orders from linked accounting software. |
  | Sales orders | Access standardized Sales orders from linked accounting software. |
  | Suppliers | Access standardized Suppliers from linked accounting software. |
  | Tax rates | Access standardized Tax rates from linked accounting software. |
  | Tracking categories | Access standardized Tracking categories from linked accounting software. |
  | Transfers | Access standardized Transfers from linked accounting software. |
  | Reports | Access standardized Reports from linked accounting software. |
  <!-- End Codat Tags Table -->

  [Read more...](https://docs.codat.io/accounting-api/overview)

  [See our OpenAPI spec](https://github.com/codatio/oas)
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->


  * [SDK Installation](https://github.com/codatio/client-sdk-python/blob/master/#sdk-installation)
  * [IDE Support](https://github.com/codatio/client-sdk-python/blob/master/#ide-support)
  * [SDK Example Usage](https://github.com/codatio/client-sdk-python/blob/master/#sdk-example-usage)
  * [Available Resources and Operations](https://github.com/codatio/client-sdk-python/blob/master/#available-resources-and-operations)
  * [File uploads](https://github.com/codatio/client-sdk-python/blob/master/#file-uploads)
  * [Retries](https://github.com/codatio/client-sdk-python/blob/master/#retries)
  * [Error Handling](https://github.com/codatio/client-sdk-python/blob/master/#error-handling)
  * [Server Selection](https://github.com/codatio/client-sdk-python/blob/master/#server-selection)
  * [Custom HTTP Client](https://github.com/codatio/client-sdk-python/blob/master/#custom-http-client)
  * [Authentication](https://github.com/codatio/client-sdk-python/blob/master/#authentication)
  * [Debugging](https://github.com/codatio/client-sdk-python/blob/master/#debugging)
  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install codat-accounting
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add codat-accounting
  ```
  <!-- End SDK Installation [installation] -->


  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared

  s = CodatAccounting(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = s.account_transactions.get(request={
      "account_transaction_id": "<value>",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  })

  if res is not None:
      
      pass
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared

  async def main():
      s = CodatAccounting(
          security=shared.Security(
              auth_header="Basic BASE_64_ENCODED(API_KEY)",
          ),
      )
      res = await s.account_transactions.get_async(request={
          "account_transaction_id": "<value>",
          "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
          "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
      })
      if res is not None:
          
          pass

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>



  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accounttransactions/README.md#get) - Get account transaction
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accounttransactions/README.md#list) - List account transactions



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accounts/README.md#create) - Create account
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accounts/README.md#get) - Get account
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accounts/README.md#get_create_model) - Get create account model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accounts/README.md#list) - List accounts



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounttransactions/README.md#create) - Create bank account transactions
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounttransactions/README.md#get_create_model) - Get create bank account transactions model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounttransactions/README.md#list) - List bank account transactions



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#create) - Create bank account
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#get) - Get bank account
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#get_create_update_model) - Get create/update bank account model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#list) - List bank accounts
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#update) - Update bank account



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billcreditnotes/README.md#create) - Create bill credit note
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billcreditnotes/README.md#get) - Get bill credit note
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billcreditnotes/README.md#get_create_update_model) - Get create/update bill credit note model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billcreditnotes/README.md#list) - List bill credit notes
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billcreditnotes/README.md#update) - Update bill credit note
  * [upload_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billcreditnotes/README.md#upload_attachment) - Upload bill credit note attachment



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billpayments/README.md#create) - Create bill payments
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billpayments/README.md#delete) - Delete bill payment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billpayments/README.md#get) - Get bill payment
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billpayments/README.md#get_create_model) - Get create bill payment model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/billpayments/README.md#list) - List bill payments



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#create) - Create bill
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#delete) - Delete bill
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#download_attachment) - Download bill attachment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#get) - Get bill
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#get_attachment) - Get bill attachment
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#get_create_update_model) - Get create/update bill model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#list) - List bills
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#list_attachments) - List bill attachments
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#update) - Update bill
  * [upload_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bills/README.md#upload_attachment) - Upload bill attachment




  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companyinfo/README.md#get) - Get company info
  * [refresh](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companyinfo/README.md#refresh) - Refresh company info



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/creditnotes/README.md#create) - Create credit note
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/creditnotes/README.md#get) - Get credit note
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/creditnotes/README.md#get_create_update_model) - Get create/update credit note model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/creditnotes/README.md#list) - List credit notes
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/creditnotes/README.md#update) - Update credit note



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#create) - Create customer
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#download_attachment) - Download customer attachment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#get) - Get customer
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#get_attachment) - Get customer attachment
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#get_create_update_model) - Get create/update customer model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#list) - List customers
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#list_attachments) - List customer attachments
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/customers/README.md#update) - Update customer



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#create) - Create direct cost
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#delete) - Delete direct cost
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#download_attachment) - Download direct cost attachment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#get) - Get direct cost
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#get_attachment) - Get direct cost attachment
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#get_create_model) - Get create direct cost model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#list) - List direct costs
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#list_attachments) - List direct cost attachments
  * [upload_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directcosts/README.md#upload_attachment) - Upload direct cost attachment



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#create) - Create direct income
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#download_attachment) - Download direct income attachment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#get) - Get direct income
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#get_attachment) - Get direct income attachment
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#get_create_model) - Get create direct income model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#list) - List direct incomes
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#list_attachments) - List direct income attachments
  * [upload_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/directincomes/README.md#upload_attachment) - Create direct income attachment



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#create) - Create invoice
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#delete) - Delete invoice
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#download_attachment) - Download invoice attachment
  * [download_pdf](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#download_pdf) - Get invoice as PDF
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#get) - Get invoice
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#get_attachment) - Get invoice attachment
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#get_create_update_model) - Get create/update invoice model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#list) - List invoices
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#list_attachments) - List invoice attachments
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#update) - Update invoice
  * [upload_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/invoices/README.md#upload_attachment) - Upload invoice attachment



  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/itemreceipts/README.md#get) - Get item receipt
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/itemreceipts/README.md#list) - List item receipts



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/items/README.md#create) - Create item
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/items/README.md#get) - Get item
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/items/README.md#get_create_model) - Get create item model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/items/README.md#list) - List items



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journalentries/README.md#create) - Create journal entry
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journalentries/README.md#delete) - Delete journal entry
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journalentries/README.md#get) - Get journal entry
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journalentries/README.md#get_create_model) - Get create journal entry model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journalentries/README.md#list) - List journal entries



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journals/README.md#create) - Create journal
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journals/README.md#get) - Get journal
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journals/README.md#get_create_model) - Get create journal model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/journals/README.md#list) - List journals



  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/paymentmethods/README.md#get) - Get payment method
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/paymentmethods/README.md#list) - List payment methods



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/payments/README.md#create) - Create payment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/payments/README.md#get) - Get payment
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/payments/README.md#get_create_model) - Get create payment model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/payments/README.md#list) - List payments
  * [payments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/payments/README.md#payments) - List payments



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#create) - Create purchase order
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#download_attachment) - Download purchase order attachment
  * [download_purchase_order_pdf](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#download_purchase_order_pdf) - Download purchase order as PDF
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#get) - Get purchase order
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#get_attachment) - Get purchase order attachment
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#get_create_update_model) - Get create/update purchase order model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#list) - List purchase orders
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#list_attachments) - List purchase order attachments
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/purchaseorders/README.md#update) - Update purchase order



  * [get_aged_creditors_report](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#get_aged_creditors_report) - Aged creditors report
  * [get_aged_debtors_report](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#get_aged_debtors_report) - Aged debtors report
  * [get_balance_sheet](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#get_balance_sheet) - Get balance sheet
  * [get_cash_flow_statement](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#get_cash_flow_statement) - Get cash flow statement
  * [get_profit_and_loss](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#get_profit_and_loss) - Get profit and loss
  * [is_aged_creditors_report_available](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#is_aged_creditors_report_available) - Aged creditors report available
  * [is_aged_debtor_report_available](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/reports/README.md#is_aged_debtor_report_available) - Aged debtors report available



  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/salesorders/README.md#get) - Get sales order
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/salesorders/README.md#list) - List sales orders



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#create) - Create supplier
  * [download_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#download_attachment) - Download supplier attachment
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#get) - Get supplier
  * [get_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#get_attachment) - Get supplier attachment
  * [get_create_update_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#get_create_update_model) - Get create/update supplier model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#list) - List suppliers
  * [list_attachments](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#list_attachments) - List supplier attachments
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/suppliers/README.md#update) - Update supplier



  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/taxrates/README.md#get) - Get tax rate
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/taxrates/README.md#list) - List all tax rates



  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/trackingcategories/README.md#get) - Get tracking categories
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/trackingcategories/README.md#list) - List tracking categories



  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transfers/README.md#create) - Create transfer
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transfers/README.md#get) - Get transfer
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transfers/README.md#get_create_model) - Get create transfer model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transfers/README.md#list) - List transfers
  * [upload_attachment](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transfers/README.md#upload_attachment) - Upload transfer attachment

  </details>
  <!-- End Available Resources and Operations [operations] -->



  <!-- Start File uploads [file-upload] -->


  Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.

  > [!TIP]
  >
  > For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.
  >

  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared

  s = CodatAccounting(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  s.bills.upload_attachment(request={
      "bill_id": "EILBDVJVNUAGVKRQ",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  })



  ```
  <!-- End File uploads [file-upload] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared
  from codataccounting.utils import BackoffStrategy, RetryConfig

  s = CodatAccounting(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = s.account_transactions.get(request={
      "account_transaction_id": "<value>",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  },
      RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

  if res is not None:
      
      pass

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared
  from codataccounting.utils import BackoffStrategy, RetryConfig

  s = CodatAccounting(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = s.account_transactions.get(request={
      "account_transaction_id": "<value>",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  })

  if res is not None:
      
      pass

  ```
  <!-- End Retries [retries] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations.  All operations return a response object or raise an error.  If Error objects are specified in your OpenAPI Spec, the SDK will raise the appropriate Error type.

  | Error Object                    | Status Code                     | Content Type                    |
  | ------------------------------- | ------------------------------- | ------------------------------- |
  | errors.ErrorMessage             | 401,402,403,404,409,429,500,503 | application/json                |
  | errors.SDKError                 | 4xx-5xx                         | */*                             |



  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import errors, shared

  s = CodatAccounting(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = None
  try:
      res = s.account_transactions.get(request={
          "account_transaction_id": "<value>",
          "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
          "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
      })

      if res is not None:
          
          pass

  except errors.ErrorMessage as e:
      
      raise(e)
  except errors.SDKError as e:
      
      raise(e)
  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  You can override the default server globally by passing a server index to the `server_idx: int` optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the indexes associated with the available servers:

  | # | Server | Variables |
  | - | ------ | --------- |
  | 0 | `https://api.codat.io` | None |



  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared

  s = CodatAccounting(
      server_idx=0,
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = s.account_transactions.get(request={
      "account_transaction_id": "<value>",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  })

  if res is not None:
      
      pass

  ```




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared

  s = CodatAccounting(
      server_url="https://api.codat.io",
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = s.account_transactions.get(request={
      "account_transaction_id": "<value>",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  })

  if res is not None:
      
      pass

  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from codat_accounting import CodatAccounting
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = CodatAccounting(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = CodatAccounting(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name          | Type          | Scheme        |
  | ------------- | ------------- | ------------- |
  | `auth_header` | apiKey        | API key       |

  You can set the security parameters through the `security` optional parameter when initializing the SDK client instance. For example:
  ```python
  from codat_accounting import CodatAccounting
  from codat_accounting.models import shared

  s = CodatAccounting(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  )

  res = s.account_transactions.get(request={
      "account_transaction_id": "<value>",
      "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
      "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
  })

  if res is not None:
      
      pass

  ```
  <!-- End Authentication [security] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from codat_accounting import CodatAccounting
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = CodatAccounting(debug_logger=logging.getLogger("codat_accounting"))
  ```
  <!-- End Debugging [debug] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->

  <!-- Start Codat Support Notes -->


  If you encounter any challenges while utilizing our SDKs, please don't hesitate to reach out for assistance.
  You can raise any issues by contacting your dedicated Codat representative or reaching out to our [support team](https://github.com/codatio/client-sdk-python/blob/master/mailto:support@codat.io).
  We're here to help ensure a smooth experience for you.
  <!-- End Codat Support Notes -->

  <!-- Start Codat Generated By -->

  <!-- End Codat Generated By -->


