# packages

pkgId: aa0e29b1c698e69be77ff6a3d361eb121a73b3ed71ce889b9f12380a83a5e52f
name: python-mcp2210-python-help
arch: noarch
version: 1.0.8
epoch: 0
release: 1
summary: Development documents and examples for mcp2210-python
url: https://github.com/jeremyherbert/mcp2210-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp2210-python-1.0.8-1.src.rpm
location_href: Packages/python-mcp2210-python-help-1.0.8-1.noarch.rpm
checksum_type: sha256
description:
  An MCP2210 python driver.

  You can install this package using `pip install mcp2210-python`.


  Documentation can be found here: [https://jeremyherbert.github.io/mcp2210-python](https://jeremyherbert.github.io/mcp2210-python)


pkgId: c94d96a235402ebe1a6c94047e7855b28636584d2d6a479f922cdb739da446da
name: python-mcp2serial-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for mcp2serial
url: https://github.com/mcp2everything/mcp2serial
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp2serial-0.1.2-1.src.rpm
location_href: Packages/python-mcp2serial-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Connect AI Large Language Models to hardware devices through the Model Context Protocol (MCP).

  [GitHub Repository](https://github.com/mcp2everything/mcp2serial) | [Documentation](https://github.com/mcp2everything/mcp2serial/tree/main/docs)



  - **Intelligent Serial Communication**
    - Automatic port detection and configuration
    - Multiple baud rate support (default 115200)
    - Real-time status monitoring and error handling

  - **PWM Control**
    - Precise frequency control (0-100Hz)
    - Real-time feedback
    - Multi-channel support

  - **MCP Protocol Integration**
    - Full Model Context Protocol support
    - Resource management and tool invocation
    - Flexible prompt system



  MCP2Serial supports all clients implementing the MCP protocol, including:

  - Claude Desktop (Full support)
  - Continue (Full support)
  - Cline (Resource + Tools)
  - Zed (Basic support)
  - Sourcegraph Cody (Resource support)
  - Firebase Genkit (Partial support)



  ```bash

  uv pip install mcp2serial


  pip install mcp2serial
  ```



  Add the following to your MCP client configuration:

  ```json
  {
      "mcpServers": {
          "mcp2serial": {
              "command": "uv",
              "args": [
                  "--directory",
                  "your_actual_path/mcp2serial",
                  "run",
                  "mcp2serial"
              ]
          }
      }
  }
  ```



  Create or modify `config.yaml` to configure serial port parameters:

  ```yaml
  serial:
    port: COM11  # Windows example, on Linux might be /dev/ttyUSB0
    baud_rate: 115200  # Baud rate
    timeout: 1.0  # Serial timeout (seconds)
    read_timeout: 0.5  # Read timeout (seconds)
  ```

  If `port` is not specified, the program will automatically search for available serial ports.



  The configuration file (`config.yaml`) can be placed in several locations. The program will search for it in the following order:

  1. Current working directory: `./config.yaml`
  2. User's home directory: `~/.mcp2serial/config.yaml`
  3. System-wide configuration:
     - Windows: `C:\ProgramData\mcp2serial\config.yaml`
     - Linux/Mac: `/etc/mcp2serial/config.yaml`

  The first valid configuration file found will be used.



  Create a `config.yaml` file in one of the above locations with the following structure:

  ```yaml
  serial:
    port: COM11  # or /dev/ttyUSB0 for Linux
    baud_rate: 115200
    timeout: 1.0
    read_timeout: 0.5

  commands:
    
    
  ```



  Add custom commands in `config.yaml`:

  ```yaml
  commands:
    
    set_pwm:
      command: "PWM {frequency}\n"  # Actual command format to send
      need_parse: false  # No need to parse response
      prompts:  # Prompt list
        - "Set PWM to {value}"
        - "Turn off PWM"

    
    led_control:
      command: "LED {state}\n"  # state can be on/off or other values
      need_parse: false
      prompts:
        - "Turn on LED"
        - "Turn off LED"
        - "Set LED state to {state}"

    
    get_sensor:
      command: "GET_SENSOR\n"
      need_parse: true  # Need to parse response
      prompts:
        - "Read sensor data"
  ```



  1. Simple Response (`need_parse: false`):
     - Device returns message starting with "OK" indicates success
     - Other responses will be treated as errors

  2. Parsed Response (`need_parse: true`):
     - Complete response will be returned in the `result.raw` field



  For detailed documentation, please visit our [GitHub repository](https://github.com/mcp2everything/mcp2serial).



  If you encounter any issues or have questions:
  1. Check our [Issues](https://github.com/mcp2everything/mcp2serial/issues) page
  2. Read our [Wiki](https://github.com/mcp2everything/mcp2serial/wiki)
  3. Create a new issue if needed



  This project is licensed under the MIT License.


pkgId: f33f811f3d8616e316ca003f164950511e9d319ceec73ec6fa3e8391d1b82609
name: python-mcpunk-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for mcpunk
url: https://pypi.org/project/mcpunk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcpunk-0.4.0-1.src.rpm
location_href: Packages/python-mcpunk-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  MCPunk provides tools for [Roaming RAG](https://arcturus-labs.com/blog/2024/11/21/roaming-rag--make-_the-model_-find-the-answers/)
  with [Model Context Protocol](https://github.com/modelcontextprotocol).

  MCPunk is built with the following in mind

  - **Context is King** - LLMs can be great but only if provided with appropriate
    context: not too long, focused and relevant.
  - **Human in the Loop** - **You** can see exactly what data the LLM has considered
    and how it found it, **You** can jump into chat and direct things wherever you want.
  - **Tools are Next** - LLMs have landed. And the vibe is that improvements are stagnating.
    The next wave of LLM-based productivity will come from the tools that use LLMs well.

  **Core functionality** allows your LLM to configure a project (e.g. a directory
  containing Python files). The files in this project are automatically "chunked".
  Each chunk is e.g. a Python function or a markdown section.
  The LLM can then query the entire project for chunks with specific names or with
  specific text in their contents. The LLM can then fetch the entire contents
  of individual chunks.

  **On top of this**, MCPunk provides tools for analysing git diffs to help
  with PR reviews, and provides a task queue that LLMs can read and write, allowing
  you to split work across multiple chats to keep context manageable.

  All this with no SaaS, no pricing, nothing (well you need a claude SaaS sub).
  Just you and Claude Desktop, with all tools running on your local machine after
  one tiny snippet in `claude_desktop_config.json`.



  First, [install uv](https://docs.astral.sh/uv/getting-started/installation/).

  Next, put the following in your `claude_desktop_config.json`.
  [Details about `claude_desktop_config.json` including location](https://glama.ai/blog/2024-11-25-model-context-protocol-quickstart#testing-mcp-using-claude-desktop).

  `"command": "uvx",` might not work, and you may need to use e.g. `"command": "/Users/michael/.local/bin/uvx",`

  ```json
  {
    "mcpServers": {
      "MCPunk": {
        "command": "uvx",
        "args": ["mcpunk"]
      }
    }
  }
  ```

  Next, start claude desktop and you should see the tools available after a small delay
  ![](assets/setup.png)

  Next, ask it to set up a project like "hey pal can you set up the ~/git/mcpunk project".
  Then start asking away, like "how is the tasks database schema structured?"



  See

  - https://arcturus-labs.com/blog/2024/11/21/roaming-rag--make-_the-model_-find-the-answers/
  - https://simonwillison.net/2024/Dec/6/roaming-rag/

  The gist of roaming RAG is

  1. Break down content (a codebase, pdf files, whatever) into "chunks".
     Each chunk is a "small" logical item like a function, a section in
     a markdown document, or all imports in a code file.
  2. Provide the LLM tools to search chunks. MCPunk does this by providing tools
     to search for files containing chunks with specific text, and to list the
     full contents of a specific chunk.

  Compared to more traditional "vector search" RAG:

  - The LLM has to drill down to find chunks, and naturally is aware of their
    broader context (like what file they're in)
  - Chunks should always be coherent. Like a full function.
  - You can see exactly what the LLM is searching for, and it's generally
    obvious if it's searching poorly and you can help it out by suggesting
    improved search terms.



  A chunk is a subsection of a file. For example,

  - A single python function
  - A markdown section
  - All the imports from a Python file
  - The diff of one file out of a multi-file diff

  Chunks are created from a file by [chunkers](mcpunk/file_chunkers.py),
  and MCPunk comes with a handful built in.

  When a project is set up in MCPunk, it goes through all files and applies
  the first matching chunker to it. The LLM can then use tools to (1) query for files
  containing chunks with specific text in them, (2) query all chunks in a specific
  file, and (3) fetch the full contents of a chunk.

  This basic foundation enables claude to effectively navigate relatively large
  codebases by starting with a broad search for relevant files and narrowing in
  on relevant areas.



  Each type of file (e.g. Python vs C) needs a custom chunker.
  MCPunk comes with some [built in](mcpunk/file_chunkers.py).
  If no specific chunker matches a file, a default chunker that just slaps
  the whole file into one chunk is used.

  The current suggested way to add chunks is to fork this project and add them,
  and run MCPunk per [Development](#development).
  To add a chunker

  - Add it in [file_chunkers.py](mcpunk/file_chunkers.py), inheriting from `BaseChunker`
  - Add it to `ALL_CHUNKERS` in [file_breakdown.py](mcpunk/file_breakdown.py)

  It would be possible to implement some kind of plugin system for modules
  to advertise that they have custom chunkers for MCPunk to use, like pytest's
  plugin system, but there are currently no plans to implement this (unless
  someone wants to do it).





  (this is a genuine race condition in MCPunk but given how things are used
  it's a big "who cares 🤷")

  - **[User]** Hey pal can you please set up the ~/git/mcpunk repo, then help me
    troubleshoot why I'm sometimes seeing that with multiple concurrent clients
    the same task can be picked up twice
  - **[Claude]** Call `configure_project`
  - **[Claude]** Call `list_files_by_chunk_type_and_chunk_contents` searching for `task` and `get_task` callables
  - **[Claude]** Call `list_all_chunk_names_in_file` for `db.py`
  - **[Claude]** Call `chunk_details` for `db.py:get_task`
  - **[Claude]** I see the potential issue - there's a race condition in the task
    retrieval process. The current implementation has a Time-Of-Check to Time-Of-Use
    (TOCTOU) vulnerability because the selection and update of the task aren't atomic....
  - **[User]** Great job pal!



  This demonstrates

  - Grab a diff between current branch and another
  - Putting tasks on a queue for other LLM chat sessions to perform
  - Running tasks from the queue

  .

  - **[user]** Hey pal can you please set up the ~/git/mcpunk repo and have a
    look at the current branch versus `scratch/1.5`
  - **[Claude]** Sets up ~/git/mcpunk and calls `diff_with_ref` for ref `scratch/1.5`
  - **[Claude]** I see you've made several changes, primarily adding a new test
    file `tests/test_git_analysis.py`...
  - **[user]** how does this fit into the rest of the codebase?
  - **[Claude]** Makes 5 tool calls for listing files by chunks, listing chunks,
    fetching chunk details
  - **[Claude]** I see - the code parses git reflog output to track recently
    checked out branches. The main function get_recent_branches takes a repo path
    and returns the last N branches that were checked out, using _branches_from_reflog
    as a helper to parse the raw reflog output.
  - **[User]** If you were in a rush and had to direct someone to review this work,
    what would you direct them to look at? Please outline discrete pieces of work
  - **[Claude]**
    - The `split("to ")[-1]` in _branches_from_reflog looks fragile
    - Test data only shows simple branch names, what about spaces/special chars?
    - Is example_reflog representative of real git reflog output?
    - Are we testing against actual git behavior?
  - **[User]** Can you please go ahead and add a single task for each of these items,
    using the task tool. Each task must be totally self contained with all relevant context,
    such that a new person could pick it up and know exactly what to do.  For example,
    it must specify to set up the project, get the diff, and look at a specific area
    with refrenc to the remainder of the codebase, then mark the task as done with
    a relevant outcome note
  - **[Claude]** (adds tasks)
    - `1.` Set up ~/git/mcpunk repo 2. Get diff between HEAD and scratch/1.5 3.
      Review _branches_from_reflog function in mcpunk/git_analysis.py, particularly
       the `split('to ')[-1]` logic 4. Check this against branch names containing
       spaces or special characters 5. If issues found, validate against git's reflog documentation
    - `1.` Set up ~/git/mcpunk repo 2. Get diff between HEAD and scratch/1.5 3.
      Compare example_reflog test data in tests/test_git_analysis.py against actual
      git reflog output from multiple repos 4. Verify it covers common reflog scenarios
      (merges, rebases, checkouts) 5. Document any missing patterns
    - `1.` Set up ~/git/mcpunk repo 2. Get diff between HEAD and scratch/1.5 3.
      Review get_recent_branches function in mcpunk/git_analysis.py 4. Verify there
      are integration tests that check the full function with a real git repo, not
      just the helper 5. If missing, document test gaps

  Start a totally new chat:

  - **[User]** Hey buddy can you please grab a task and complete it
  - **[Claude]** grabs a task, sets up project, gets diff, digs around project
  - **[Claude]** discusses details
  - **[Claude]** marks task done with note:

  ```
  Found potential issues with _branches_from_reflog function:
  1. Current implementation is brittle as it uses simple string splitting
  2. Could fail with branch names containing \"to \"
  3. May break with non-standard reflog entries
  Recommend using regex pattern matching to properly parse reflog format

  follow_up_criticality: medium
  ```



  You can just ask your LLM to set up multiple projects, and it can freely query
  across them. Handy if one depends on the other, and they're in different repos.
  In this case the LLM should recognise this via imports.



  - Sometimes LLM is poor at searching. e.g. search for "dependency", missing
    terms "dependencies". Room to stem things.
  - Sometimes LLM will try to find a specific piece of critical code but fail to
    find it, then continue without acknowledging it has limited contextual awareness.
  - "Large" projects are not well tested. A project with ~1000 Python files containing
    in total ~250k LoC works well. Takes ~5s to setup the project. As codebase
    size increases, time to perform initial chunking will increase, and likely
    more sophisticated searching will be required.



  Various things can be configured via environment variables.
  For available options, see [settings.py](mcpunk/settings.py) - these are loaded
  from env vars via [Pydantic Settings](https://github.com/pydantic/pydantic-settings).



  MCPunk is at a minimum usable state right now.

  **Critical Planned functionality**

  - Add a bunch of prompts to help with using MCPunk. Without real "explain how to make
    a pancake to an alien"-type prompts things do fall a little flat.

  **High up on the roadmap**

  - Improved logging, likely into the db itself
  - Possibly stemming for search
  - Change the whole "project" concept to not need files to actually exist - this
    leads to allowing "virtual" files inside the project.
    - Consider changing files from having a path to having a URI, so coule be like
      `file://...` / `http[s]://` / `gitdiff://` / etc arbitrary URIs
  - Integrate with web searching
    - Flow like (1) LLM says "search for Caridina water parameters" (2) tool
      does web search and grabs the 10 highest pages and converts to markdown and
      chunks them and puts them in the virtual filesystem (3) LLM queries for chunks
      etc like usual.
  - Chunking of git diffs. Currently, there's a tool to fetch an entire diff. This
    might be very large. Instead, the tool could be changed to `add_diff_to_project`
    and it puts files under the `gitdiff://` URI or under some fake path
  - Database tweaks
    - Maybe migrations. More than likely just if db version has changed make a backup
      copy of the old one and start from scratch.
    - If db needs stay so simple, just switch to JSON file on disk. Multithread/process
      considerations.
  - Include module-level comments when extracting python module-level statements.
  - Caching of a project, so it doesn't need to re-parse all files every time you
    restart MCP client. This may be tricky as changes to the code in a chunker
    will make cache invalid.
  - Handle changed files sensibly, so you don't need to restart MCP client
    and re-add project on any file changes
  - Ability to edit files - why not? Can do it like aider where LLM produces a diff.
  - Ability for users to provide custom code to perform chunking, perhaps
    similar to [pytest plugins](https://docs.pytest.org/en/stable/how-to/writing_plugins.html#making-your-plugin-installable-by-others)

  **Just ideas**

  - Something like tree sitter could possibly be used for a more generic chunker
  - Better handling of large chunks
    - Configurable Max response size for chunks
    - Log warning for any chunk over max size when initialising project
  - Tracking of characters sent/received, ideally by chat.
  - State, logging, etc by chat



  see [run_mcp_server.py](mcpunk/run_mcp_server.py).

  If you set up claude desktop like below then you can restart it to see latest
  changes as you work on MCPunk from your local version of the repo.

  ```json
  {
    "mcpServers": {
      "MCPunk": {
        "command": "/Users/michael/.local/bin/uvx",
        "args": [
          "--from",
          "/Users/michael/git/mcpunk",
          "--no-cache",
          "mcpunk"
        ]
      }
    }
  }
  ```



  See the [Makefile](Makefile) and github actions workflows.


pkgId: ddce93c47ca04a301d7e037b30f40fa010844dafa2ecf9714f3612a06049941a
name: python-md2fileo-help
arch: noarch
version: 1.3.17
epoch: 0
release: 1
summary: Development documents and examples for md2fileo
url: https://github.com/Michal-D4/fileo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-md2fileo-1.3.17-1.src.rpm
location_href: Packages/python-md2fileo-help-1.3.17-1.noarch.rpm
checksum_type: sha256
description:
  This application is about the files, your files.

  Fileo[fɑɪlɔ] - could be FileOrganizer, but that doesn't matter.

  The graphical interface is shown in the image below.

  ![fileo](https://github.com/Michal-D4/fileo/raw/main/img/fileo.jpg)



  1. application mode, it determinates how files in the list (8) is selected.
  2. the button to display menu to hide/show the widgets("Folders", "Tags", "File Extensions", "Authors") on the left pane.
  3. Describes how the list of files (8) was created.
  4. buttons related to the file list (8):
     * ![recent](https://github.com/Michal-D4/fileo/raw/main/img/recent.png) - show list of recent files
     * ![search](https://github.com/Michal-D4/fileo/raw/main/img/search.png) - search files by name,
     * ![fields](https://github.com/Michal-D4/fileo/raw/main/img/more.png) - selecting the columns that will be visible in the file list
  5. a group of buttons for working with the folder tree: previous-next folder in the history of visited folders; show hidden folders; collapse all branches - expand the last branch if all branches were collapsed.
  6. left toolbar, it contains the following buttons from top to bottom:
     1. menu button
     2. switch to "DIR" mode, the file list displays files from the current folder
     3. switch to the "FILTER" mode, the file list displays files according to the filter settings
     4. open filter settings dialog, switch to "FILTER_SETUP" mode
     5. hide/show left pane
  7. the folder tree window
  8. the file list window
  9. panel for displaying/editing file data: notes, tags, authors (for books), file locations (file can be located in several folders)
  10. current database name, click on it to enter list of available databases
  11. folder tree branch from root to current folder
  12. the current file in file list
  13. the name of the file whose note is open in the editor, this is not displaying if no note is edited, click here to go to this file and the folder containing this file
  14. number of files in the file list

  The application works in three main modes: DIR, FILTER and FILTER_SETUP.
  * In DIR mode, files are selected by the current directory in the "Folders" widget.
  * In FILTER mode, files are selected according to the parameters choosen in the FILTER_SETUP dialog.
  * In FILTER_SETUP mode. The filter setup dialog is openning, the file list is changing only by clicking the "Apply" or "Done" button.

  There are three additional application modes: RECENT_FILES, FOUND_FILES and FILE_BY_REF.
  * RECENT_FILES - list of files you've recently done something with
  * FOUND_FILES - list of files you found using the search dialog
  * FILE_BY_REF - the file list window contains a file referenced from the note of some file. The transition to this mode occurs after clicking on the link.

  In FILTER mode, the list of files depends on the filter options set in FILTER_SETUP mode. The filter may depend on the selected folders, selected tags, and selected authors in the boxes in the left pane. In FILTER_SETUP mode, the list of files does not change when changing the selected folders, tags, authors. But in FILTER mode, any changes are immediately displayed in the list of files.



  As said, the app is about files. Files have a number of attributes:

  1. name
  2. path, the user practically does not see it, only by opening the directory or copying the full file name and on the "File Info" page
  3. file extension
  4. tags
  5. rating
  6. author(s) - usually for books
  7. dates of:
      1. modification
      2. last opening
      3. creation
      4. publication (books)
      5. date of last created/modified note to the file
  8. number of file openings
  9. size in bytes
  10. number of pages - usually for books



  Folders are not associated with file system directories, the path is used for that. You can freely create, move, copy and delete folders in the folder tree, the files will remain intact. You can, for example, create multiple folder hierarchies, this can be handy. Of course, if you delete all folders it will be impossible to access files using folder tree, but they remain accessible by filter. The next time the **`@@Lost`** folder will appear, it can be used to access files that are not in any other folder.
  You can also *copy/move files from one folder to another*  by dragging *with the left or right mouse button pressed*.



  It may happen that there are duplicate files on your disk. It is highly recommended to delete duplicate files. If you need different versions of a file, consider using a version control system such as Git.

  Fileo can find files that are identical in content, but only if these files are added to the same fileo session, or rather to the same database. Fileo works with only one database at a time. You can create a report on duplicate files from the main menu:

  ![Duplicates](https://github.com/Michal-D4/fileo/raw/main/img/Duplicates.jpg)

  After creating the report (if duplicates are detected), you can delete all duplicates at once. But it may be better to remove them manually or delete the selected file in the "Locations" page, since the application may remove not the duplicate file you expected.





  There are two method to add files:

  1. Open "Search for files..." dialog with main menu item "Scan disk for files": ![scan_disk_dialog](https://github.com/Michal-D4/fileo/raw/main/img/scan_disk_dialog.png)

  2. drag files from the file explorer (or similar application) to the folder in the folder tree.

  > **Note**. Scanning the file system can be quite lengthy, so it is performed in a separate thread.
  > The red circle in the lower left corner is a sign that the thread is working:
  >
  > ![image-20230213184306153](https://github.com/Michal-D4/fileo/raw/main/img/image-20230213184306153.png)
  >
  > Only one background thread can run at a time - this is the design of the application. The user interface is not blocking but you should avoid to perform operation that make changes in the database, for example, drag-drop operations. But you can change the list of files by changing a current folder or filter, or you can open files.

  3. You can export the selected files (with all their attributes) from the database using the context menu of the file list:

     ![export-files](https://github.com/Michal-D4/fileo/raw/main/img/export-files.jpg)

     and then import them to another database

     ![import-files](https://github.com/Michal-D4/fileo/raw/main/img/import-files.jpg)

     to the folder "New folder" in this case.

     > **Note**. In the file note you can have reference(s) to another file(s) in the data base. If you drag the file with such note the reference will be broken, there is no interbase references.

  File duplicates



  First you should setup the filter:

  ![image-20230213185910924](https://github.com/Michal-D4/fileo/raw/main/img/image-20230213185910924.png)

  With the filter set in the picture, the list of files will include files from the any of `DB`, `ML` or `Rust` folders that have at least one of the `Math`, `ML` or `package` tags, have a rating higher than 4 and were opened after `2022-09-14 00:00:00`.

  > **Note.** In case of before &mdash; the date before or equal to `2022-11-14 23:59:59`.

  The Apply button applies a specified filter without closing the Filter Setup dialog box.

  The Done button applies the filter, closes the dialog, and switches the application to "**Filter Mode**". In this mode, when you change the selection in any of the fields on the left panel (Folders, Tags, Extensions, Authors), the list of files immediately changes.



  ![image-20230428203253627](https://github.com/Michal-D4/fileo/raw/main/img/find_file.jpg)

  The search is performed by pressing the Enter key. "Aa" is a case sensitive search, if checked, "ab" - exact search, but you can use wildcards: "*" - any number of any letters, or "?" - any single letter.



  ![fileo-comments](https://github.com/Michal-D4/fileo/raw/main/img/file-notes.jpg)

  1. "+"  plus button - add new note and open it in the editor
  8.  the button to collapse all notes
  3. start editing of the note
  4. "x" button - delete the note
  5. external (http) reference, can be open in the system web browser



  ![edit-comment](https://github.com/Michal-D4/fileo/raw/main/img/edit-comment.jpg)

  1. the button to save changes, save changes and close editor
  2. the button to discard changes

  > pressing any of these buttons closes the editor

  Note is a markdown text. You can insert here web links and links to file(s) registered in the application (in the current DB).



  ![tag-selector](https://github.com/Michal-D4/fileo/raw/main/img/tag-selector.jpg)

  1. The list of tags associated with the current file. You can input here a list of tags separated by commas. *It is the only place where the new tag can be created.* The new tags will appear in the list 2 and 4.
  2. The list of tags. The tags selected in this list apply to the file filter.
  3. The context menu in the list of tags. Selected tags are highlighted ('Linux' and 'package'). The tag  'package' is a current tag (last selected).
  4. The tag selector. The tags selected here will appear in the list 1.



  ![author-selector](https://github.com/Michal-D4/fileo/raw/main/img/author-selector.jpg)

  1. The list of authors associated with the current file. You can input here a list of authors separated by commas (in square brackets if author name contains comma as in "Vaughan, Lee", otherwise it may be entered without brackets, but new authors without brackets must be in the end of list). It is the only place where the new author can be created. The new authors will appear in the list 2 and 4.
  2. The list of authors. The authors selected in this list apply to the file filter.
  3. The context menu in the list of authors. The current tag is highlighted - "Vijay  Pande" in this case.
  4. The author selector. The authors selected here will appear in the list 1.



  The file may be located in different folders. In fact, these are links to the same file[^1] in different folders. The file location is represented as a branch of folders from the root folder to the folder in which the link to the file is saved.

  ![Locations](https://github.com/Michal-D4/fileo/raw/main/img/Locations.jpg)

  1 - list of branches, where the current file can be found. The list also includes the file duplicates, if any. Duplicates are marked with "`----> Dup:`" followed by the name of the duplicate; A duplicate file may have a different name than the file itself; duplicates are identified by identical content.

  The location marked with a bullet is a current location.

  2 - a context menu:

  1. copy - copy selected lines
  2. go to this location - go to the file in the folder under mouse cursor
  3. Reveal in explorer - show file in explorer
  4. delete file from this location - in fact the link to the file is removed from the folder under the mouse cursor, the file itself remains intact
  5. Remove duplicate file - the file under mouse cursor will be removed to the trash bin if duplicate of the file exists
  6. Select All

  3 - the current branch

  4 - the current file selected in the file list

  The letters "L" and "H" in brackets means "Link" and "Hidden". "Link" and "Hidden" are attributes of folder. For example, the folder "fill" in the branch 2 is a link to the folder "fill"[^2] in the second line both "Link" and "Hidden"

  <img src="https://github.com/Michal-D4/fileo/raw/main/img/Folders.jpg" alt="Folders"  />

  1. The current folder (fill).
  2. The check box. It is used to switch the "FOLDERS" widget to the "Show hidden folders" mode. The folders "@@Lost" and "fill" are hidden; "folder2"[^2] is link to "folder2" above "to have 2 folders".
     **Note.** The only difference between folder and link to it is that when you delete folder all its links and all its children will be deleted too, whereas deletion of any link of folder does not impact any other folder.
  3. The current file "angle_down_20221002213631.svg".

  [^1]:with one exception, the file may be duplicated, i.e. there may be more than one file with the same content.
  [^2]: A folder link always has the same name as the folder itself, because the link is a simple pair of folder IDs: the first is the folder ID, the second is the parent folder ID. A folder can have many parent folders. The first parent is set when the folder is created, all the others are set when the folder is copied to another (parent) folder.



  ![file-info](https://github.com/Michal-D4/fileo/raw/main/img/file-info.jpg)

  The "File rating" and "Pages" can be edited here. But they also can be edited directly in the file list if visible:

  ![file-list-fields](https://github.com/Michal-D4/fileo/raw/main/img/file-list-fields.jpg)

  1. The file list
  2. Menu to select fields visible in the file list. The checked fields are visible, the field "File Name" is always visible.





  ![file_context_menu](https://github.com/Michal-D4/fileo/raw/main/img/file_context_menu.png)

  Almost all operations with files are shown in the context menu on the picture.

  Besides them you can copy / move files from one folder to another.

  You can also open files by double clicking on "File name". If the file is executable, it will be executed, not opened. Thus, the application can be used as a "Start Menu", it can be even more convenient than the standard "Start Menu".

  > **Note:** If you delete a file from a folder, the file will still remain in the DB, even if you delete it from all folders, it can be found by searching by name or part of the name, or using a filter, or at least it will appear in (hidden) folder "@@Lost".
  > If you delete a file from the DB, it will be deleted from all folders, and all notes for this file and its links to tags and authors will be lost.

  ***



  All application data is stored into a data base (SQlite DB). The SQlite data base is a single file, you can create as many DB files as you want. All manipulation with the DB files are performing in the DB selector:

  ![DB-selector](https://github.com/Michal-D4/fileo/raw/main/img/DB-selector.jpg)

  The DB can be opened in the current window by double click on the line in the DB list, or select with keybord up and down arrows key and choose with "Return" key, not "Enter" key on numeric keybord.



  Three color themes have been created for the application: “Default”, “Light” and “Dark”.

  You can switch theme in the preferences menu item:

  ![image-20240505145226631](https://github.com/Michal-D4/fileo/raw/main/img//preferences_in_main_menu.png)

  ![image-20240505145706247](https://github.com/Michal-D4/fileo/raw/main/img//color_themes.png)



  * Windows. Download the installer `fileo_setup.x.y.z.exe`  from [sourceforge](https://sourceforge.net/projects/fileo/) where `x.y.z` - version and run it.



  * Linux and Windows
    install as Python package from PyPi:

    ```
      > pip install md2fileo
    ```
    and then run with
    ```
      > python -m fileo
    ```


pkgId: c21d049c405e63b841618bd84aa854f188508cbfa918374edf6e6170b3a110cf
name: python-mdclense-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for mdclense
url: https://github.com/boadzie/mdclense
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdclense-0.1.2-1.src.rpm
location_href: Packages/python-mdclense-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  > A lightweight, efficient Python library for converting Markdown to plain text. `mdclense` strips away all Markdown formatting while preserving the original content, making it perfect for text analysis, content extraction, and data processing pipelines.



  - Comprehensive Markdown support
  - Preserves content while removing formatting
  - Handles complex nested structures
  - Clean whitespace management
  - JSON-like structure support
  - Zero dependencies beyond Python standard library



  - Headers (ATX and Setext style)
  - Emphasis (bold, italic, bold-italic)
  - Links and images
  - Lists (ordered, unordered, and task lists)
  - Code blocks and inline code
  - Blockquotes
  - Tables
  - Horizontal rules
  - HTML tags
  - Strikethrough
  - Footnotes
  - Escaped characters



  ```bash
  pip install mdclense
  ```



  ```python
  from mdclense.parser import MarkdownParser



  parser = MarkdownParser()


  markdown_text = """


  This is a **bold** and *italic* text with a [link](http://example.com).

  - List item 1
  - List item 2
  """

  plain_text = parser.parse(markdown_text)
  print(plain_text)
  ```

  Output:

  ```
  Hello World

  This is a bold and italic text with a link.

  List item 1
  List item 2
  ```





  ```python

  json_text = '"answer": "This is **bold** text with a [link](url)"'
  plain_text = parser.parse(json_text)
  print(plain_text)  # Output: This is bold text with a link
  ```



  ````python
  markdown_text = '''
  Here's some code:

  ```python
  def hello():
      print("world")
  ````

  '''

  plain_text = parser.parse(markdown_text)
  print(plain_text) # Code blocks are replaced with [CODE BLOCK] placeholder

  ````





  ```python
  class MarkdownParser:
      def parse(markdown_text: str) -> str:
          """
          Convert markdown text to plain text by removing all markdown formatting.

          Args:
              markdown_text (str): The markdown text to be converted

          Returns:
              str: Plain text without markdown formatting
          """
  ````



  Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request



  ```bash

  pip install pytest


  pytest tests/
  ```



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.



  - Inspired by the need for a simple, dependency-free Markdown to plain text converter
  - Thanks to all contributors who have helped shape this project


pkgId: 2f009b5ac8f126ba7ef9acec21c5d7b64cf17f3fb3950b82981da226c0bf5a16
name: python-mdformat-help
arch: noarch
version: 0.7.21
epoch: 0
release: 1
summary: Development documents and examples for mdformat
url: https://github.com/hukkin/mdformat
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdformat-0.7.21-1.src.rpm
location_href: Packages/python-mdformat-help-0.7.21-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  [![Documentation Status](https://readthedocs.org/projects/mdformat/badge/?version=latest)](https://mdformat.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://github.com/hukkin/mdformat/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/hukkin/mdformat/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
  [![codecov.io](https://codecov.io/gh/hukkin/mdformat/branch/master/graph/badge.svg)](https://codecov.io/gh/hukkin/mdformat)
  [![PyPI version](https://img.shields.io/pypi/v/mdformat)](https://pypi.org/project/mdformat)



  > CommonMark compliant Markdown formatter

  </div>

  <!-- start mini-description -->

  Mdformat is an opinionated Markdown formatter
  that can be used to enforce a consistent style in Markdown files.
  Mdformat is a Unix-style command-line tool as well as a Python library.

  <!-- end mini-description -->

  Find out more in the [docs](https://mdformat.readthedocs.io).

  <!-- start installing -->



  Install with [CommonMark](https://spec.commonmark.org/current/) support:

  ```bash
  pipx install mdformat
  ```

  Install with [GitHub Flavored Markdown (GFM)](https://github.github.com/gfm/) support:

  ```bash
  pipx install mdformat
  pipx inject mdformat mdformat-gfm
  ```

  Note that GitHub's Markdown renderer supports syntax extensions not included in the GFM specification.
  For full GitHub support do:

  ```bash
  pipx install mdformat
  pipx inject mdformat mdformat-gfm mdformat-frontmatter mdformat-footnote mdformat-gfm-alerts
  ```

  Install with [Markedly Structured Text (MyST)](https://myst-parser.readthedocs.io/en/latest/using/syntax.html) support:

  ```bash
  pipx install mdformat
  pipx inject mdformat mdformat-myst
  ```

  <!-- end installing -->

  <!-- start cli-usage -->





  Format files `README.md` and `CHANGELOG.md` in place

  ```bash
  mdformat README.md CHANGELOG.md
  ```

  Format `.md` files in current working directory recursively

  ```bash
  mdformat .
  ```

  Read Markdown from standard input until `EOF`.
  Write formatted Markdown to standard output.

  ```bash
  mdformat -
  ```



  ```bash
  mdformat --check README.md CHANGELOG.md
  ```

  This will not apply any changes to the files.
  If a file is not properly formatted, the exit code will be non-zero.



  ```console
  foo@bar:~$ mdformat --help
  usage: mdformat [-h] [--check] [--no-validate] [--version] [--number]
                  [--wrap {keep,no,INTEGER}] [--end-of-line {lf,crlf,keep}]
                  [--exclude PATTERN] [--extensions EXTENSION]
                  [--codeformatters LANGUAGE]
                  [paths ...]

  CommonMark compliant Markdown formatter

  positional arguments:
    paths                 files to format

  options:
    -h, --help            show this help message and exit
    --check               do not apply changes to files
    --no-validate         do not validate that the rendered HTML is consistent
    --version             show program's version number and exit
    --number              apply consecutive numbering to ordered lists
    --wrap {keep,no,INTEGER}
                          paragraph word wrap mode (default: keep)
    --end-of-line {lf,crlf,keep}
                          output file line ending mode (default: lf)
    --exclude PATTERN     exclude files that match the Unix-style glob pattern
                          (multiple allowed)
    --extensions EXTENSION
                          require and enable an extension plugin (multiple
                          allowed) (use `--no-extensions` to disable) (default:
                          all enabled)
    --codeformatters LANGUAGE
                          require and enable a code formatter plugin (multiple
                          allowed) (use `--no-codeformatters` to disable)
                          (default: all enabled)
  ```

  The `--exclude` option is only available on Python 3.13+.

  <!-- end cli-usage -->



  This README merely provides a quickstart guide for the command line interface.
  For more information refer to the [documentation](https://mdformat.readthedocs.io).
  Here's a few pointers to get you started:

  - [Style guide](https://mdformat.readthedocs.io/en/stable/users/style.html)
  - [Python API usage](https://mdformat.readthedocs.io/en/stable/users/installation_and_usage.html#python-api-usage)
  - [Usage as a pre-commit hook](https://mdformat.readthedocs.io/en/stable/users/installation_and_usage.html#usage-as-a-pre-commit-hook)
  - [Plugin usage](https://mdformat.readthedocs.io/en/stable/users/plugins.html)
  - [Plugin development guide](https://mdformat.readthedocs.io/en/stable/contributors/contributing.html)
  - [List of code block formatter plugins](https://mdformat.readthedocs.io/en/stable/users/plugins.html#existing-plugins)
  - [List of parser extension plugins](https://mdformat.readthedocs.io/en/stable/users/plugins.html#id1)
  - [Changelog](https://mdformat.readthedocs.io/en/stable/users/changelog.html)

  <!-- start faq -->





  Mdformat is a CommonMark formatter.
  It doesn't have out-of-the-box support for syntax other than what is defined in [the CommonMark specification](https://spec.commonmark.org/current/).

  The custom syntax that these Markdown engines introduce typically redefines the meaning of
  angle brackets, square brackets, parentheses, hash character — characters that are special in CommonMark.
  Mdformat often resorts to backslash escaping these characters to ensure its formatting changes never alter a rendered document.

  Additionally some engines, namely MkDocs,
  [do not support](https://github.com/mkdocs/mkdocs/issues/1835) CommonMark to begin with,
  so incompatibilities are unavoidable.

  Luckily mdformat is extensible by plugins.
  For many Markdown engines you'll find support by searching
  [the plugin docs](https://mdformat.readthedocs.io/en/stable/users/plugins.html)
  or [mdformat GitHub topic](https://github.com/topics/mdformat).

  You may also want to consider a documentation generator that adheres to CommonMark as its base syntax
  e.g. [mdBook](https://rust-lang.github.io/mdBook/)
  or [Sphinx with Markdown](https://www.sphinx-doc.org/en/master/usage/markdown.html).



  Mdformat is pure Python code!
  Python is pre-installed on macOS and virtually any Linux distribution,
  meaning that typically little to no additional installations are required to run mdformat.
  This argument also holds true when using together with
  [pre-commit](https://github.com/pre-commit/pre-commit) (also Python).
  Prettier on the other hand requires Node.js/npm.

  Prettier suffers from
  [numerous](https://github.com/prettier/prettier/issues?q=is%3Aopen+label%3Alang%3Amarkdown+label%3Atype%3Abug+)
  bugs,
  many of which cause changes in Markdown AST and rendered HTML.
  Many of these bugs are a consequence of using
  [`remark-parse`](https://github.com/remarkjs/remark/tree/main/packages/remark-parse)
  v8.x as Markdown parser which,
  according to the author themselves,
  is [inferior to markdown-it](https://github.com/remarkjs/remark/issues/75#issuecomment-143532326) used by mdformat.
  `remark-parse` v9.x is advertised as CommonMark compliant
  and presumably would fix many of the issues,
  but is not used by Prettier (v3.3.3) yet.

  Prettier (v3.3.3), being able to format many languages other than Markdown,
  is a large package with 73 direct dependencies
  (mdformat only has one in Python 3.11+).
  This can be a disadvantage in many environments,
  one example being size optimized Docker images.

  Mdformat's parser extension plugin API allows not only customization of the Markdown specification in use,
  but also advanced features like [automatic table of contents generation](https://github.com/hukkin/mdformat-toc).
  Also provided is a code formatter plugin API enabling integration of embedded code formatting for any programming language.



  Nope, the logo is actually pretty great – you're terrible.
  The logo is more a piece of art than a logo anyways,
  depicting the horrors of poorly formatted text documents.
  I made it myself!

  That said, if you have any graphic design skills and want to contribute a revised version, a PR is more than welcome 😄.

  <!-- end faq -->

rpm_license:
  MIT License  Copyright (c) 2021 Taneli Hukkinen  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: ec8a39f8fc80550c27f6aeb5f0d185460412d10011a0820e0812022496287e96
name: python-mdformat_deflist-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for mdformat_deflist
url: https://github.com/executablebooks/mdformat-deflist
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdformat_deflist-0.1.3-1.src.rpm
location_href: Packages/python-mdformat_deflist-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status][ci-badge]][ci-link]
  [![codecov.io][cov-badge]][cov-link]
  [![PyPI version][pypi-badge]][pypi-link]

  An [mdformat](https://github.com/executablebooks/mdformat) plugin for [markdown-it-deflist](https://github.com/markdown-it/markdown-it-deflist).



  This package utilises [flit](https://flit.readthedocs.io) as the build engine, and [tox](https://tox.readthedocs.io) for test automation.

  To install these development dependencies:

  ```bash
  pip install tox
  ```

  To run the tests:

  ```bash
  tox
  ```

  and with test coverage:

  ```bash
  tox -e py37-cov
  ```

  The easiest way to write tests, is to edit tests/fixtures.md

  To run the code formatting and style checks:

  ```bash
  tox -e py37-pre-commit
  ```

  or directly

  ```bash
  pip install pre-commit
  pre-commit run --all
  ```

  To run the pre-commit hook test:

  ```bash
  tox -e py37-hook
  ```



  Either use flit directly:

  ```bash
  pip install flit
  flit publish
  ```

  or trigger the GitHub Action job, by creating a release with a tag equal to the version, e.g. `v0.0.1`.

  Note, this requires generating an API key on PyPi and adding it to the repository `Settings/Secrets`, under the name `PYPI_KEY`.

  [ci-badge]: https://github.com/executablebooks/mdformat-deflist/workflows/CI/badge.svg?branch=master
  [ci-link]: https://github.com/executablebooks/mdformat/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush
  [cov-badge]: https://codecov.io/gh/executablebooks/mdformat-deflist/branch/master/graph/badge.svg
  [cov-link]: https://codecov.io/gh/executablebooks/mdformat-deflist
  [pypi-badge]: https://img.shields.io/pypi/v/mdformat-deflist.svg
  [pypi-link]: https://pypi.org/project/mdformat-deflist


pkgId: ffc6ecfdc4dabaee3b6e7a3ce79a1b075e7b8e80a22da80b8f9b902739f15e65
name: python-mdformat_mkdocs-help
arch: noarch
version: 4.0.0
epoch: 0
release: 1
summary: Development documents and examples for mdformat_mkdocs
url: https://pypi.org/project/mdformat_mkdocs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdformat_mkdocs-4.0.0-1.src.rpm
location_href: Packages/python-mdformat_mkdocs-help-4.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status][ci-badge]][ci-link] [![PyPI version][pypi-badge]][pypi-link]

  <!-- [![codecov.io][cov-badge]][cov-link]
  [cov-badge]: https://codecov.io/gh/executablebooks/mdformat-mkdocs/branch/main/graph/badge.svg
  [cov-link]: https://codecov.io/gh/executablebooks/mdformat-mkdocs
   -->

  An [mdformat](https://github.com/executablebooks/mdformat) plugin for [mkdocs](https://github.com/mkdocs/mkdocs) and packages commonly used with MkDocs ([mkdocs-material](https://squidfunk.github.io/mkdocs-material), [mkdocstrings](https://mkdocstrings.github.io), and [python-markdown](https://python-markdown.github.io))

  Supports:

  - Indents are converted to four-spaces instead of two
      - *Note*: when specifying `--align-semantic-breaks-in-lists`, the nested indent for ordered lists is three, but is otherwise a multiple of four
  - Unordered list bullets are converted to dashes (`-`) instead of `*`
  - By default, ordered lists are standardized on a single digit (`1.` or `0.`) unless `--number` is specified, then `mdformat-mkdocs` will apply consecutive numbering to ordered lists [for consistency with `mdformat`](https://github.com/executablebooks/mdformat?tab=readme-ov-file#options)
  - [MkDocs-Material Admonitions](https://squidfunk.github.io/mkdocs-material/reference/admonitions)
  - [MkDocs-Material Content Tabs\*](https://squidfunk.github.io/mkdocs-material/reference/content-tabs)
      - \*Note: the markup (HTML) rendered by this plugin is sufficient for formatting but not for viewing in a browser. Please open an issue if you have a need to generate valid HTML.
  - [mkdocstrings Anchors (autorefs)](https://mkdocstrings.github.io/autorefs/#markdown-anchors)
  - [mkdocstrings Cross-References](https://mkdocstrings.github.io/usage/#cross-references)
  - [Python Markdown "Abbreviations"\*](https://squidfunk.github.io/mkdocs-material/reference/tooltips/#adding-abbreviations)
      - \*Note: the markup (HTML) rendered for abbreviations is not useful for rendering. If important, I'm open to contributions because the implementation could be challenging

  See the example test files, [./tests/pre-commit-test.md](https://raw.githubusercontent.com/KyleKing/mdformat-mkdocs/main/tests/pre-commit-test.md) and [./tests/format/fixtures.md](https://raw.githubusercontent.com/KyleKing/mdformat-mkdocs/main/tests/format/fixtures.md)



  Add this package wherever you use `mdformat` and the plugin will be auto-recognized. No additional configuration necessary. For additional information on plugins, see [the official `mdformat` documentation here](https://mdformat.readthedocs.io/en/stable/users/plugins.html)

  **Tip**: this package specifies an "extra" (`'recommended'`) for plugins that work well with typical documentation managed by `mkdocs`:

  - [mdformat-beautysh](https://pypi.org/project/mdformat-beautysh)
  - [mdformat-black](https://pypi.org/project/mdformat-black)
  - [mdformat-config](https://pypi.org/project/mdformat-config)
  - [mdformat-footnote](https://pypi.org/project/mdformat-footnote)
  - [mdformat-frontmatter](https://pypi.org/project/mdformat-frontmatter)
  - [mdformat-simple-breaks](https://pypi.org/project/mdformat-simple-breaks)
  - [mdformat-tables](https://pypi.org/project/mdformat-tables)
  - [mdformat-web](https://pypi.org/project/mdformat-web)
  - [mdformat-wikilink](https://github.com/tmr232/mdformat-wikilink)



  ```yaml
  repos:
    - repo: https://github.com/executablebooks/mdformat
      rev: 0.7.18
      hooks:
        - id: mdformat
          additional_dependencies:
            - mdformat-mkdocs
            
            
  ```



  ```sh
  pipx install mdformat
  pipx inject mdformat mdformat-mkdocs
  ```

  Or with uv:

  ```sh
  uv tool run --from mdformat-mkdocs mdformat
  ```



  To generate HTML output, any of the plugins can be imported from `mdit_plugins`. For more guidance on `MarkdownIt`, see the docs: <https://markdown-it-py.readthedocs.io/en/latest/using.html#the-parser>

  ```py
  from markdown_it import MarkdownIt

  from mdformat_mkdocs.mdit_plugins import (
      material_admon_plugin,
      material_content_tabs_plugin,
      mkdocstrings_autorefs_plugin,
      mkdocstrings_crossreference_plugin,
      pymd_abbreviations_plugin,
  )

  md = MarkdownIt()
  md.use(material_admon_plugin)
  md.use(material_content_tabs_plugin)
  md.use(mkdocstrings_autorefs_plugin)
  md.use(mkdocstrings_crossreference_plugin)
  md.use(pymd_abbreviations_plugin)

  text = "- Line 1\n    - `bash command`\n    - Line 3"
  md.render(text)








  ```



  `mdformat-mkdocs` adds the CLI argument `--align-semantic-breaks-in-lists` to optionally align line breaks in numbered lists to 3-spaces. If not specified, the default of 4-indents is followed universally.

  ```txt

  1. Semantic line feed where the following line is
      three spaces deep


  1. Semantic line feed where the following line is
     three spaces deep
  ```

  Note: the `align-semantic-breaks-in-lists` setting is not supported in the configuration file yet (https://github.com/executablebooks/mdformat/issues/378)



  See [CONTRIBUTING.md](https://github.com/kyleking/mdformat-mkdocs/blob/main/CONTRIBUTING.md)

  [ci-badge]: https://github.com/kyleking/mdformat-mkdocs/workflows/CI/badge.svg?branch=main
  [ci-link]: https://github.com/kyleking/mdformat-mkdocs/actions?query=workflow%3ACI+branch%3Amain+event%3Apush
  [pypi-badge]: https://img.shields.io/pypi/v/mdformat-mkdocs.svg
  [pypi-link]: https://pypi.org/project/mdformat-mkdocs


pkgId: 5ca3e5bb04b0529f8f52c5027d52abfd121c0e254853ca70dfee6709b06781a2
name: python-mdinterface-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mdinterface
url: https://gitlab.com/roncofaber/mdinterface
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdinterface-1.0.0-1.src.rpm
location_href: Packages/python-mdinterface-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  `mdinterface` is a Python package for building systems to use in Molecular Dynamics (MD) simulations. The package was primarly developed to help construct electrolyte/electrode interfaces, but is well suited to generate suitable MD boxes of liquids, electrolyte systems and polymer networks.



  - Create and configure molecular systems with solvents, solutes, and interfaces.
  - Generate simulation boxes for MD simulations.
  - Populate boxes with ions and solvents using PACKMOL.
  - Automatically write LAMMPS data files and coefficients.
  - Database of common liquids/gases with pre-defined classical force fields parameters.
  - Generate polymer chains from given monomers.



  Check the file [requirements.txt](requirements.txt) to see which packages are needed. Installing the package using `pip` should already take care of all dependencies.





  You can simply install the latest release of the package and all dependencies using:

  ```bash
  pip install mdinterface
  ```



  Alternatively you can obtain `mdinterface` directly from the repository by following those steps:

  Clone the repository in the desired location:

  ```bash
  git clone git@gitlab.com:roncofaber/mdinterface.git
  ```

  Install the required packages:

  ```bash
  cd mdinterface
  conda install -c conda-forge --file requirements.txt
  ```

  Install the package with pip:

  ```bash
  pip install .
  ```



  If you plan of making changes, clone the package and install the requirements but then add it to your development environment with:

  ```bash
  pip install --no-build-isolation --no-deps -e .
  ```


pkgId: 25534c614df1e49e7251ed7eb3c63609578396b6860f16784e699aafaee22ef1
name: python-mdmodels-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mdmodels
url: https://pypi.org/project/mdmodels/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdmodels-0.1.0-1.src.rpm
location_href: Packages/python-mdmodels-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This is the Python package for the MDModels Rust crate and hosts a set of tools to work with metadata models defined in markdown.

  **Whats in the bag?**

  - **Core** - The core functionality to work with MDModels
  - **PyDantic** - Generate Pydantic models (on steroids) from MDModels
  - **LLM tools** - Use LLMs to extract, transform and explore data
  - **SQL tools** - Create SQL databases and query them with SQLAlchemy
  - **Graph tools** - Create graph databases and query them with SPARQL

  One note before you start: This package is work in progress and the API will likely change in the future. Issues and contributions are very welcome!



  To install the package, you can use the following command:

  ```bash
  pip install mdmodels


  pip install mdmodels[chat]


  pip install mdmodels[graph]


  pip install mdmodels[sql]


  pip install mdmodels[all]
  ```



  To get you started, have a look at the [examples](./examples) folder, featuring notebooks that showcase the usage of the package. This is what is available right now:

  - [Core](./examples/basic)
      - [Basic](./examples/basic) - Basic usage of the core functionality
  - [LLM tools](./examples/llm)
      - [Question Answering](./examples/llm/answering) - Use LLMs to answer questions about the data
      - [Metadata Extraction](./examples/llm/extraction) - Use LLMs to extract metadata from text and to databases
      - [Metadata Mapping](./examples/llm/mapping) - Use LLMs to map metadata from one format to another
      - [Similarity Search](./examples/llm/embedding) - Use LLMs to find similar items in a database
  - [SQL tools](./examples/sql)
      - [Basic](./examples/sql/basic) - Create a SQL database and interact with it
  - [Graph tools](./examples/graph)
      - [Basic](./examples/graph/basic) - Create a graph database and interact with it


pkgId: 1f3897f63955acd62aab8bb3016bc1dd318eed9ea49a40d7eb1b01d94569d4fb
name: python-mdps-ds-lib-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for mdps-ds-lib
url: https://pypi.org/project/mdps-ds-lib/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdps-ds-lib-1.1.1-1.src.rpm
location_href: Packages/python-mdps-ds-lib-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  - https://pypi.org/project/mdps-ds-lib/


  - `conda create -n uds_lib_39 python=3.9`
  - `conda activate uds_lib_39`
  - `python -m poetry build`
  - `python3 -m twine upload --repository pypi dist/*`


pkgId: 83355be9165cade16edb213a4cf41dfbe2aef3a64048fc54344daf05d7fb2600
name: python-mdx-spanner-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mdx-spanner
url: https://gitlab.com/mschleeweiss/mdx_spanner
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mdx-spanner-0.1.0-1.src.rpm
location_href: Packages/python-mdx-spanner-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This package enables `rowspan` and `colspan` in markdown tables when using [MkDocs](https://www.mkdocs.org/).





  You can activate `colspan` by putting only `~~` in a cell. This will merge the cell with the cell in the previous column.

  You can activate `rowspan` by putting `__` in a cell. This will merge the cell with the cell in the previous row. If the cell in previous row is empty it will continue to merge until it finds a non-empty cell.

  Sample:

  ```md
  | Header 1 | Header 2 | Header 3 |
  | ---------| -------- | -------- |
  | Value 1  |    ~~    | Value 2  |
  |          |    ~~    | Value 3  |
  |_        _|    ~~    | Value 5  |
  | Value 6  | Value 7  | Value 8  |
  ```

  This should result in the following table:
  ```md
  +----------+----------+----------+
  | Header 1 | Header 2 | Header 3 |
  +----------+----------+----------+
  | Value 1             | Value 2  |
  |                     +----------+
  |                     | Value 3  |
  |                     +----------+
  |                     | Value 5  |
  +----------+----------+----------+
  | Value 6  | Value 7  | Value 8  |
  +----------+----------+----------+
  ```



  You can change the alignment of a single spanned cell by adding markers to the spanning indicators.

  To change the horizontal alignment (when multiple columns are merged) put colons before and/or after the `~~` to indicate the alignment:

  | Sample | Result |
  | ------ | ------ |
  | `:~~`  | Left aligned |
  | `:~~:`  | Centered |
  | `~~:`  | Right aligned |

  <br>
  To change the vertical alignment (when multiple rows are merged) put one of the following chars (`^`,`=`,`_`) between the `__` to indicate the alignment:

  | Sample | Result |
  | ------ | ------ |
  | `_^_`  | Top aligned |
  | `_=_`  | Centered |
  | `___`  | Bottom aligned |

  Sample:

  ```md
  | Header 1   | Header 2 | Header 3 |
  | ---------- | -------- | -------- |
  | Value 1    |   :~~:   | Value 2  |
  |            |    ~~    | Value 3  |
  |_     =    _|    ~~    | Value 5  |
  | Value 6    | Value 7  | Value 8  |
  ```
  This should result in the following table:


  ```md
  +----------+----------+----------+
  | Header 1 | Header 2 | Header 3 |
  +----------+----------+----------+
  |                     | Value 2  |
  |                     +----------+
  |       Value 1       | Value 3  |
  |                     +----------+
  |                     | Value 5  |
  +----------+----------+----------+
  | Value 6  | Value 7  | Value 8  |
  +----------+----------+----------+
  ```




  ```console
  $ pip install mdx_spanner
  ```



  After installing the extension you can add it in the `mkdocs.yml` file:

  ```yaml
  site_name: ...
  nav:
    ...
  theme:
    ...
  markdown_extensions:
    - mdx_spanner
  ```


pkgId: dc82b5ce9e71ffca4e562dbda5291e59ed1305dde7e1c9ac9301f4ed00d44514
name: python-mediaaccount-help
arch: noarch
version: 0.8.12
epoch: 0
release: 1
summary: Development documents and examples for mediaaccount
url: https://github.com/ckrowiorsch/mediaaccount-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mediaaccount-0.8.12-1.src.rpm
location_href: Packages/python-mediaaccount-help-0.8.12-1.noarch.rpm
checksum_type: sha256
description:
  Documentation for the api hier: <http://api.media-account.de/>

  Package found here: <https://pypi.org/project/mediaaccount/>



  The client supports the python logging-package for detailed information.



  ```python
  import datetime
  from mediaaccount import MediaAccountClient

  apiKey = '123456789'
  client = MediaAccountClient(api_key=apiKey)


  articles, nextlink, count = client.articles('ImportDatum', von = '01.05.2021', bis = '05.08.2021', maxItems=150)
  articles, nextPageLink, count = client.articleNext(nextPageLink)


  scroll = client.scroll('ImportDatum', von = '04.08.2021', bis = '05.08.2021', maxItems=1000)
  articlesAll = [i[0] for i in scroll]
  ```





  ```bash
      ./publish.sh test     # publish to test
  ```

  ```bash
      ./publish.sh prod     # publish to prod
  ```



  Board: <https://github.com/CKrowiorsch/mediaaccount-py/projects/1>

  * Integration Api-V3


pkgId: 67b97cf7f75fc5f0ad6814fbeb77283486e86df43907dc0096c7b37a3b44801d
name: python-mediacloud-metadata-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for mediacloud-metadata
url: https://mediacloud.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mediacloud-metadata-1.4.0-1.src.rpm
location_href: Packages/python-mediacloud-metadata-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a package to extract a domain, title, publication date, text, and language content from the URL or text of an
  online news story. The methods for each are extracted from the larger [Media Cloud project](https://mediacloud.org),
  but also build on numerous 3rd party libraries. The metadata extracted includes:
  * the original URL of publication
  * a normalized URL useful for de-duplication
  * the canonical domain published on
  * the date of publication
  * the primary language used in the article text
  * the title of the article
  * a normalized title useful for de-duplication
  * the text content of the news article
  * the name of the library used to extract the article content
  Other often-reused methods and configuration related to the mediacloud service also live in this package.


pkgId: 106e64f4c6a08310ca23568ba6e0b0d12ce2534d9078ed30c40f682fc378e5e1
name: python-medic-ml-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for medic-ml
url: https://elinaff.github.io/MeDIC/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-medic-ml-0.1.0-1.src.rpm
location_href: Packages/python-medic-ml-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Metabolomic Dashboard for Interpretable Classification


  The MeDIC is a tool to apply machine learning algorithms to untargeted metabolomics datasets acquired by liquid-chromatography mass spectrometry. The goal is to extract the most important features because they are potential novel biomarkers.
  The interface is made to be easy to use and intuitive even for those with small to nonexistant experience in programming and AI.


  You can find the documentation [here](https://elinaff.github.io/MeDIC/).
  It explains how to use MeDIC but also how it works.


   - [Élina Francovic-Fontaine](https://github.com/ElinaFF)
   - [Vincent Primpied](https://github.com/le-smog)
   - [Vincent Vilain](https://github.com/VincentVilain)


  MeDIC is still in development. If you encounter any issue or have any suggestion, feel free to contact us at [elina.francovic-fontaine.1@ulaval.ca](mailto:elina.francovic-fontaine.1@ulaval.ca). Or you can leave an issue [here](https://github.com/ElinaFF/MeDIC/issues) with the tag "bug".





  Clone the project with :
  ```shell
  git clone https://github.com/ElinaFF/MeDIC.git
  ```

  It is recommanded to setup a virtual environment. When it's done, use your isolated python and install `medic` package locally and in editable mode with :
  ```shell
  python -m pip install -e ".[dev]"
  ```



  Let's say you want to update to version `1.3.2`.
     1.  Make sure the main branch is working fine, either run `pytest` locally or trigger a tests workflow manually.
     1.  Set the version to `__version__ = "1.3.2"` in [medic/__init__.py](./medic/__init__.py) (you can edit a file from GitHub by clicking on the key `.` on your keyboard)
     2.  Commit the new version change with `git add medic/__init__.py` and `git commit -m "Bump version`
     3.  Push the commit with `git push`
     4.  Go to https://github.com/ElinaFF/MeDIC/releases/new, choose a tag, create new tag with name `1.3.2`
     5.  Document what have changed since the last release (you can try the `Generate release notes` button)
     6.  Click `Publish release`!


pkgId: f932ea1f15efc476083755fe00c094f369d15c533efee6c4de2540704d71fdb4
name: python-meds-evaluation-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for meds-evaluation
url: https://github.com/kamilest/meds-evaluation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-meds-evaluation-0.0.1-1.src.rpm
location_href: Packages/python-meds-evaluation-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Evaluation API for the MEDS Decentralized Extensible Validation
  [MEDS-DEV](https://github.com/mmcdermott/MEDS-DEV/) Benchmark.

  > \[!NOTE\]
  > This is a **work-in-progress** package and currently only supports evaluation of binary classification
  > tasks.



  MEDS Evaluation pipeline is intended to be used together with
  [MEDS-DEV](https://github.com/mmcdermott/MEDS-DEV/), but can also be adapted to use as a standalone package.

  Please refer to the
  [MEDS-DEV tutorial](https://github.com/mmcdermott/MEDS-DEV?tab=readme-ov-file#example-workflow) to learn how
  to extract and prepare the data in the MEDS format and obtain model predictions ready to be evaluated.



  Inputs to MEDS Evaluation must follow the *prediction schema*, which by default has five fields:

  1. `subject_id`: ID of the subject (patient) associated with the event
  2. `prediction_time`: time at which the prediction as being made
  3. `boolean_value`: ground truth boolean label for the prediction task
  4. `predicted_boolean_value` (optional): predicted boolean label generated by the model
  5. `predicted_boolean_probability` (optional): predicted probability logits generated by the model

  This is equivalent to the following `polars` schema:

  ```python
  Schema(
      [
          ("subject_id", Int64),
          ("prediction_time", Datetime(time_unit="us")),
          ("boolean_value", Boolean),
          ("predicted_boolean_value", Boolean),
          ("predicted_boolean_probability", Float64),
      ]
  )
  ```

  Note that while `predicted_boolean_value` and `predicted_boolean_probability` are optional, at least one of
  them must be present and contain non-null values in order to generate the results. In addition, a schema can
  contain additional fields but at the moment these will not be used in MEDS Evaluation.


pkgId: 1b21f669667112386267bd148080ef960867ffba366291cdd2e865c4b9c28e98
name: python-meds-torch-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for meds-torch
url: https://github.com/oufattole/meds-torch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-meds-torch-0.0.5-1.src.rpm
location_href: Packages/python-meds-torch-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://pytorch.org/get-started/locally/"><img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-ee4c2c?logo=pytorch&logoColor=white"></a>
  <a href="https://pytorchlightning.ai/"><img alt="Lightning" src="https://img.shields.io/badge/-Lightning-792ee5?logo=pytorchlightning&logoColor=white"></a>
  <a href="https://hydra.cc/"><img alt="Config: Hydra" src="https://img.shields.io/badge/Config-Hydra-89b8cd"></a>
  <a href="https://github.com/ashleve/lightning-hydra-template"><img alt="Template" src="https://img.shields.io/badge/-Lightning--Hydra--Template-017F2F?style=flat&logo=github&labelColor=gray"></a>
  <a href="https://www.python.org/downloads/release/python-3100/"><img alt="Python" src="https://img.shields.io/badge/-Python_3.12+-blue?logo=python&logoColor=white"></a>
  <a href="https://pypi.org/project/meds-torch/"><img alt="PyPI" src="https://img.shields.io/badge/PyPI-v0.0.1a1-blue?logoColor=blue"></a>
  <a href="https://hydra.cc/"><img alt="Hydra" src="https://img.shields.io/badge/Config-Hydra_1.3-89b8cd"></a>
  <a href="https://codecov.io/github/Oufattole/meds-torch"><img src="https://codecov.io/github/Oufattole/meds-torch/graph/badge.svg?token=BV119L5JQJ"/></a>
  <a href="https://github.com/Oufattole/meds-torch/actions/workflows/tests.yaml"><img alt="Tests" src="https://github.com/Oufattole/meds-torch/actions/workflows/tests.yaml/badge.svg"></a>
  <a href="https://github.com/Oufattole/meds-torch/actions/workflows/code-quality-main.yaml"><img alt="Code Quality" src="https://github.com/Oufattole/meds-torch/actions/workflows/code-quality-main.yaml/badge.svg"></a>
  <a href="https://github.com/Oufattole/meds-torch/graphs/contributors"><img alt="Contributors" src="https://img.shields.io/github/contributors/oufattole/meds-torch.svg"></a>
  <a href="https://github.com/Oufattole/meds-torch/pulls"><img alt="Pull Requests" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg"></a>
  <a href="https://github.com/Oufattole/meds-torch#license"><img alt="License" src="https://img.shields.io/badge/License-MIT-green.svg?labelColor=gray"></a>
  <a href='https://meds-torch.readthedocs.io/en/latest/?badge=latest'><img src='https://readthedocs.org/projects/meds-torch/badge/?version=latest' alt='Documentation Status' /></a>





  ```bash
  pip install meds-torch
  ```



  ```bash

  PATHS_KWARGS="paths.data_dir=/CACHED/NESTED/RAGGED/TENSORS/DIR paths.meds_cohort_dir=/PATH/TO/MEDS/DATA/ paths.output_dir=/OUTPUT/RESULTS/DIRECTORY"


  TASK_KWARGS="data.task_name=NAME_OF_TASK data.task_root_dir=/PATH/TO/TASK/LABELS/"
  ```



  1. Train a supervised model (GPU)

  ```bash
  meds-torch-train trainer=gpu $PATHS_KWARGS $TASK_KWARGS
  ```

  2. Pretrain an autoregressive forecasting model (GPU)

  ```bash
  meds-torch-train trainer=gpu $PATHS_KWARGS model=eic_forecasting
  ```

  3. Train with a specific experiment configuration

  ```bash
  meds-torch-train experiment=experiment.yaml $PATHS_KWARGS $TASK_KWARGS hydra.searchpath=[pkg://meds_torch.configs,/PATH/TO/CUSTOM/CONFIGS]
  ```

  4. Override parameters

  ```bash
  meds-torch-train trainer.max_epochs=20 data.batch_size=64 $PATHS_KWARGS $TASK_KWARGS
  ```

  5. Hyperparameter search

  ```bash
  meds-torch-tune trainer=ray callbacks=tune_default hparams_search=ray_tune experiment=triplet_mtr $PATHS_KWARGS $TASK_KWARGS hydra.searchpath=[pkg://meds_torch.configs,/PATH/TO/CUSTOM/CONFIGS/WITH/experiment/triplet_mtr]
  ```



  For detailed examples and tutorials:

  - Check `MIMICIV_INDUCTIVE_EXPERIMENTS/README.md` for a comprehensive guide to using MEDS-torch with MIMIC-IV data, including data preparation, task extraction, and running experiments with different tokenization and transfer learning methods.
  - See `ZERO_SHOT_TUTORIAL/README.md` for a rough WIP walkthrough of zero-shot prediction (and please share feedback on improving this! 🙂)



  Here's a sample `experiment.yaml`:

  ```yaml


  defaults:
    - override /data: pytorch_dataset
    - override /logger: wandb
    - override /model/backbone: triplet_transformer_encoder
    - override /model/input_encoder: triplet_encoder
    - override /model: supervised
    - override /trainer: gpu

  tags: [mimiciv, triplet, transformer_encoder]

  seed: 0

  trainer:
    min_epochs: 1
    max_epochs: 10
    gradient_clip_val: 1.0

  data:
    dataloader:
      batch_size: 64
      num_workers: 6
    max_seq_len: 128
    collate_type: triplet
    subsequence_sampling_strategy: to_end

  model:
    token_dim: 128
    optimizer:
      lr: 0.001
    backbone:
      n_layers: 2
      nheads: 4
      dropout: 0

  logger:
    wandb:
      tags: ${tags}
      group: mimiciv_tokenization
  ```

  This configuration sets up a supervised learning experiment using a triplet transformer encoder on MIMIC-IV data. Modify this file to suit your specific needs.



  - **Flexible ML Pipeline**: Utilizes Hydra for dynamic configuration and PyTorch Lightning for scalable training.
  - **Advanced Tokenization**: Supports multiple strategies for embedding EHR data (Triplet, Text Code, Everything In Code).
  - **Supervised Learning**: Train models on arbitrary tasks defined in MEDS format data.
  - **Transfer Learning**: Pretrain models using contrastive learning, forecasting, and other methods, then finetune for specific tasks.
  - **Multiple Pretraining Methods**: Supports EBCL, OCP, STraTS Value Forecasting, and Autoregressive Observation Forecasting.





  ```bash
  pip install meds-torch
  ```



  ```bash
  git clone git@github.com:Oufattole/meds-torch.git
  cd meds-torch
  pip install -e .
  ```



  For detailed usage instructions, API reference, and examples, visit our [documentation](https://meds-torch.readthedocs.io/).

  For a comprehensive demo of our pipeline and to see results from a suite of inductive experiments comparing different tokenization methods and learning approaches, please refer to the `MIMICIV_INDUCTIVE_EXPERIMENTS/README.MD` file. This document provides detailed scripts and performance metrics.





  ```bash
  bash MIMICIV_INDUCTIVE_EXPERIMENTS/launch_supervised.sh $MIMICIV_ROOT_DIR meds-torch
  ```



  ```bash

  bash MIMICIV_INDUCTIVE_EXPERIMENTS/launch_multi_window_pretrain.sh $MIMICIV_ROOT_DIR meds-torch [METHOD]
  bash MIMICIV_INDUCTIVE_EXPERIMENTS/launch_ar_pretrain.sh $MIMICIV_ROOT_DIR meds-torch [AR_METHOD]


  bash MIMICIV_INDUCTIVE_EXPERIMENTS/launch_finetune.sh $MIMICIV_ROOT_DIR meds-torch [METHOD]
  bash MIMICIV_INDUCTIVE_EXPERIMENTS/launch_ar_finetune.sh $MIMICIV_ROOT_DIR meds-torch [AR_METHOD]
  ```

  Replace `[METHOD]` with one of the following:

  - `ocp` (Observation Contrastive Pretraining)
  - `ebcl` (Event-Based Contrastive Learning)
  - `value_forecasting` (STraTS Value Forecasting)

  Replace `[AR_METHOD]` with one of the following:

  - `eic_forecasting` (Everything In Code Forecasting)
  - `triplet_forecasting` (Triplet Forecasting)

  These scripts allow you to run various experiments, including supervised learning, different pretraining methods, and finetuning for both standard and autoregressive models.



  For questions, issues, or feature requests, please open an issue on our [GitHub repository](https://github.com/Oufattole/meds-torch/issues).

  ______________________________________________________________________

  MEDS-torch: Advancing healthcare machine learning through flexible, robust, and scalable sequence modeling tools.


pkgId: e6c881d78ac09e1a58bdcebea2aae06fb1a73b9474fe4f448351b131c83a1a5c
name: python-megaparse-sdk-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for megaparse-sdk
url: https://pypi.org/project/megaparse-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-megaparse-sdk-0.1.9-1.src.rpm
location_href: Packages/python-megaparse-sdk-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to the MegaParse SDK! This SDK allows you to easily interact with the MegaParse API to upload URLs and files for processing.



  To install the MegaParse SDK, use pip:

  ```sh
  pip install megaparse-sdk
  ```



  Here is an example of how to use the MegaParse SDK:



  ```python
  import asyncio
  import os

  from megaparse.sdk import MegaParseSDK

  async def upload_url():
      api_key = str(os.getenv("MEGAPARSE_API_KEY"))
      megaparse = MegaParseSDK(api_key)

      url = "https://www.quivr.com"

      
      url_response = await megaparse.url.upload(url)
      print(f"\n----- URL Response : {url} -----\n")
      print(url_response)

      await megaparse.close()

  if __name__ == "__main__":
      asyncio.run(upload_url())
  ```



  ```python
  import asyncio
  import os

  from megaparse.sdk import MegaParseSDK

  async def upload_file():
      api_key = str(os.getenv("MEGAPARSE_API_KEY"))
      megaparse = MegaParseSDK(api_key)

      file_path = "your/file/path.pdf"
      
      response = await megaparse.file.upload(
          file_path=file_path,
          method="unstructured",  # unstructured, llama_parser, megaparse_vision
          strategy="auto",
      )
      print(f"\n----- File Response : {file_path} -----\n")
      print(response)

      await megaparse.close()

  if __name__ == "__main__":
      asyncio.run(upload_file())
  ```



  - **Upload URLs**: Easily upload URLs for processing.
  - **Upload Files**: Upload files with different processing methods and strategies.



  1. **Set up your API key**: Make sure to set the `MEGAPARSE_API_KEY` environment variable with your MegaParse API key.
  2. **Run the example**: Use the provided example to see how to upload URLs and files.

  For more details, refer to the [usage example](#file:usage_example.py-context).

  We hope you find the MegaParse SDK useful for your projects!

  Enjoy, _Quivr Team_ !


pkgId: 1bbb22366278b171530606a1d0d40c28e415e97681b32b0ce08b8605367a52bc
name: python-mem0ai-help
arch: noarch
version: 0.1.35
epoch: 0
release: 1
summary: Development documents and examples for mem0ai
url: https://pypi.org/project/mem0ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mem0ai-0.1.35-1.src.rpm
location_href: Packages/python-mem0ai-help-0.1.35-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/mem0ai/mem0">
    <img src="docs/images/banner-sm.png" width="800px" alt="Mem0 - The Memory Layer for Personalized AI">
    </a>
  <p align="center"><a href=https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps target='_blank'><img alt=Launch YC: Mem0 - Open Source Memory Layer for AI Apps src=https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps/upvote_embed.svg/></a></p>


    <p align="center">
      <a href="https://mem0.ai">Learn more</a>
      ·
      <a href="https://mem0.dev/DiG">Join Discord</a>
    </p>
  </p>

  <p align="center">
    <a href="https://mem0.dev/DiG">
      <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Mem0 Discord">
    </a>
    <a href="https://pepy.tech/project/mem0ai">
      <img src="https://img.shields.io/pypi/dm/mem0ai" alt="Mem0 PyPI - Downloads" >
    </a>
    <a href="https://pypi.org/project/mem0ai" target="_blank">
          <img src="https://img.shields.io/pypi/v/mem0ai?color=%2334D058&label=pypi%20package" alt="Package version">
      </a>
      <a href="https://www.npmjs.com/package/mem0ai" target="_blank">
          <img src="https://img.shields.io/npm/v/mem0ai" alt="Npm package">
      </a>
    <a href="https://www.ycombinator.com/companies/mem0">
      <img src="https://img.shields.io/badge/Y%20Combinator-S24-orange?style=flat-square" alt="Y Combinator S24">
    </a>
  </p>




  [Mem0](https://mem0.ai) (pronounced as "mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. Mem0 remembers user preferences, adapts to individual needs, and continuously improves over time, making it ideal for customer support chatbots, AI assistants, and autonomous systems.

  <!-- Start of Selection -->
  <p style="display: flex;">
    <span style="font-size: 1.2em;">New Feature: Introducing Graph Memory. Check out our <a href="https://docs.mem0.ai/open-source/graph-memory" target="_blank">documentation</a>.</span>
  </p>
  <!-- End of Selection -->




  - **Multi-Level Memory**: User, Session, and AI Agent memory retention
  - **Adaptive Personalization**: Continuous improvement based on interactions
  - **Developer-Friendly API**: Simple integration into various applications
  - **Cross-Platform Consistency**: Uniform behavior across devices
  - **Managed Service**: Hassle-free hosted solution



  Mem0 leverages a hybrid database approach to manage and retrieve long-term memories for AI agents and assistants. Each memory is associated with a unique identifier, such as a user ID or agent ID, allowing Mem0 to organize and access memories specific to an individual or context.

  When a message is added to the Mem0 using add()  method, the system extracts relevant facts and preferences and stores it across data stores: a vector database, a key-value database, and a graph database. This hybrid approach ensures that different types of information are stored in the most efficient manner, making subsequent searches quick and effective.

  When an AI agent or LLM needs to recall memories, it uses the search() method. Mem0 then performs search across these data stores, retrieving relevant information from each source. This information is then passed through a scoring layer, which evaluates their importance based on relevance, importance, and recency. This ensures that only the most personalized and useful context is surfaced.

  The retrieved memories can then be appended to the LLM's prompt as needed, enhancing the personalization and relevance of its responses.



  Mem0 empowers organizations and individuals to enhance:

  - **AI Assistants and agents**: Seamless conversations with a touch of déjà vu
  - **Personalized Learning**: Tailored content recommendations and progress tracking
  - **Customer Support**: Context-aware assistance with user preference memory
  - **Healthcare**: Patient history and treatment plan management
  - **Virtual Companions**: Deeper user relationships through conversation memory
  - **Productivity**: Streamlined workflows based on user habits and task history
  - **Gaming**: Adaptive environments reflecting player choices and progress



  The easiest way to set up Mem0 is through the managed [Mem0 Platform](https://app.mem0.ai). This hosted solution offers automatic updates, advanced analytics, and dedicated support. [Sign up](https://app.mem0.ai) to get started.

  If you prefer to self-host, use the open-source Mem0 package. Follow the [installation instructions](#install) to get started.



  Install the Mem0 package via pip:

  ```bash
  pip install mem0ai
  ```

  Alternatively, you can use Mem0 with one click on the hosted platform [here](https://app.mem0.ai/).



  Mem0 requires an LLM to function, with `gpt-4o` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/llms).

  First step is to instantiate the memory:

  ```python
  from mem0 import Memory

  m = Memory()
  ```

  <details>
  <summary>How to set OPENAI_API_KEY</summary>

  ```python
  import os
  os.environ["OPENAI_API_KEY"] = "sk-xxx"
  ```
  </details>


  You can perform the following task on the memory:

  1. Add: Store a memory from any unstructured text
  2. Update: Update memory of a given memory_id
  3. Search: Fetch memories based on a query
  4. Get: Return memories for a certain user/agent/session
  5. History: Describe how a memory has changed over time for a specific memory ID

  ```python

  result = m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="alice", metadata={"category": "hobbies"})


  ```

  ```python

  result = m.update(memory_id=<memory_id_1>, data="Likes to play tennis on weekends")


  ```

  ```python

  related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")


  ```

  ```python

  all_memories = m.get_all()
  memory_id = all_memories["memories"][0] ["id"] # get a memory_id


  ```

  ```python

  history = m.history(memory_id=<memory_id_1>)


  ```

  > [!TIP]
  > If you prefer a hosted version without the need to set up infrastructure yourself, check out the [Mem0 Platform](https://app.mem0.ai/) to get started in minutes.



  To initialize Graph Memory you'll need to set up your configuration with graph store providers.
  Currently, we support Neo4j as a graph store provider. You can setup [Neo4j](https://neo4j.com/) locally or use the hosted [Neo4j AuraDB](https://neo4j.com/product/auradb/).
  Moreover, you also need to set the version to `v1.1` (*prior versions are not supported*).
  Here's how you can do it:

  ```python
  from mem0 import Memory

  config = {
      "graph_store": {
          "provider": "neo4j",
          "config": {
              "url": "neo4j+s://xxx",
              "username": "neo4j",
              "password": "xxx"
          }
      },
      "version": "v1.1"
  }

  m = Memory.from_config(config_dict=config)

  ```



  For detailed usage instructions and API reference, visit our documentation at [docs.mem0.ai](https://docs.mem0.ai). Here, you can find more information on both the open-source version and the hosted [Mem0 Platform](https://app.mem0.ai).



  [![Star History Chart](https://api.star-history.com/svg?repos=mem0ai/mem0&type=Date)](https://star-history.com/#mem0ai/mem0&Date)



  Join our community for support and discussions. If you have any questions, feel free to reach out to us using one of the following methods:

  - [Join our Discord](https://mem0.dev/DiG)
  - [Follow us on Twitter](https://x.com/mem0ai)
  - [Email founders](mailto:founders@mem0.ai)



  Join our [Discord community](https://mem0.dev/DiG) to learn about memory management for AI agents and LLMs, and connect with Mem0 users and contributors. Share your ideas, questions, or feedback in our [GitHub Issues](https://github.com/mem0ai/mem0/issues).

  We value and appreciate the contributions of our community. Special thanks to our contributors for helping us improve Mem0.

  <a href="https://github.com/mem0ai/mem0/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=mem0ai/mem0" />
  </a>



  We collect anonymous usage metrics to enhance our package's quality and user experience. This includes data like feature usage frequency and system info, but never personal details. The data helps us prioritize improvements and ensure compatibility. If you wish to opt-out, set the environment variable MEM0_TELEMETRY=false. We prioritize data security and don't share this data externally.



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.


pkgId: f68a76c98830f7bc427ff782692f91d343d16eee5ef11e559094d47b8f2afcc6
name: python-meme-generator-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for meme-generator
url: https://github.com/MeetWq/meme-generator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-meme-generator-0.1.9-1.src.rpm
location_href: Packages/python-meme-generator-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="https://s2.loli.net/2023/03/26/4URd1BKj3ToycLl.png" width=200 />



  _✨ 表情包生成器，用于制作各种沙雕表情包 ✨_

  <p align="center">
    <img src="https://img.shields.io/github/license/MeetWq/meme-generator" alt="license">
    <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python">
    <a href="https://pypi.org/project/meme-generator">
      <img src="https://badgen.net/pypi/v/meme-generator" alt="pypi">
    </a>
    <a href="https://jq.qq.com/?_wv=1027&k=wDVNrMdr">
      <img src="https://img.shields.io/badge/QQ%E7%BE%A4-682145034-orange" alt="qq group">
    </a>
  </p>

  </div>



  表情详细信息、表情预览等可以在 [--> 表情列表 <--](https://github.com/MeetWq/meme-generator/wiki/%E8%A1%A8%E6%83%85%E5%88%97%E8%A1%A8) 查看



  详见 Wiki：[--> Wiki <--](https://github.com/MeetWq/meme-generator/wiki)



  如果希望编写、贡献新的表情，可以参考 [--> 新表情编写指北 <--](https://github.com/MeetWq/meme-generator/wiki/%E6%96%B0%E8%A1%A8%E6%83%85%E7%BC%96%E5%86%99%E6%8C%87%E5%8C%97)

  对于一些不适合放在主仓库的表情，可以提交至 [--> 额外表情仓库 <--](https://github.com/MeetWq/meme-generator-contrib)



  本仓库的表情素材等均来自网络，如有侵权请联系作者删除



  本仓库的表情整合自原 [nonebot-plugin-petpet](https://github.com/noneplugin/nonebot-plugin-petpet) 和 [nonebot-plugin-memes](https://github.com/noneplugin/nonebot-plugin-memes) 仓库

  感谢以下开发者作出的贡献：

  <a href="https://github.com/noneplugin/nonebot-plugin-petpet/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=noneplugin/nonebot-plugin-petpet&max=1000" />
  </a>

  部分表情素材或代码参考了以下项目，感谢这些项目的开发者们

  - [Ailitonia/omega-miya](https://github.com/Ailitonia/omega-miya) 基于nonebot2的qq机器人
  - [FloatTech/ZeroBot-Plugin](https://github.com/FloatTech/ZeroBot-Plugin) 基于 ZeroBot 的 OneBot 插件
  - [HibiKier/zhenxun_bot](https://github.com/HibiKier/zhenxun_bot) 基于 Nonebot2 和 go-cqhttp 开发，以 postgresql 作为数据库，非常可爱的绪山真寻bot
  - [SAGIRI-kawaii/sagiri-bot](https://github.com/SAGIRI-kawaii/sagiri-bot) 基于Graia Ariadne和Mirai的QQ机器人 SAGIRI-BOT
  - [Dituon/petpet](https://github.com/Dituon/petpet) Mirai插件 生成各种奇怪的图片
  - [kexue-z/nonebot-plugin-nokia](https://github.com/kexue-z/nonebot-plugin-nokia) 诺基亚手机图生成
  - [RafuiiChan/nonebot_plugin_charpic](https://github.com/RafuiiChan/nonebot_plugin_charpic) 字符画生成插件


pkgId: 0cacbd9d6a650eb6fcdf36d9c2452203ea5f6dcb63ff090a02364a65e062d1cd
name: python-memium-help
arch: noarch
version: 0.25.21
epoch: 0
release: 1
summary: Development documents and examples for memium
url: https://pypi.org/project/memium/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-memium-0.25.21-1.src.rpm
location_href: Packages/python-memium-help-0.25.21-1.noarch.rpm
checksum_type: sha256
description:
  [![Open in Dev Container](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)][dev container]
  [![PyPI](https://img.shields.io/pypi/v/memium.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/memium)][pypi status]
  [![Roadmap](https://img.shields.io/badge/Board-Roadmap-green)][roadmap]

  [dev container]: https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/MartinBernstorff/memium/
  [pypi status]: https://pypi.org/project/memium/
  [documentation]: https://MartinBernstorff.github.io/memium/
  [roadmap]: https://github.com/users/MartinBernstorff/projects/2

  <!-- start short-description -->

  When you have to stop and look things up, it breaks up your flow. Adding this knowledge to long-term memory builds fluency, and being fluent at something makes it much more fun! The faster you can get from crawling to running, the more enjoyable it is.

  Unfortunately, we forget most of what we read, [even stuff we care about](https://andymatuschak.org/books/).

  It turns out that if you ask questions of the texts you read, and ask those questions of yourself in the future, you learn much more! But writing questions and quizzing yourself can feel quite mechanical. What if you wrote questions as part of your notes, and then your computer could quiz you in the future? That's the purpose of Memium. It extracts questions from your notes like

  ```
  Q. Why can spaced repetition result in more enjoyable learning?
  A. It enables faster bootstrapping to proficiency, which is more fun!
  ```

  And adding them to a spaced repetition service like [Anki](https://apps.ankiweb.net).

  This is an implementation of Andy Matuschak's [Personal Mnemonic Medium](https://notes.andymatuschak.org/The_mnemonic_medium_can_be_extended_to_one%E2%80%99s_personal_notes).

  <!-- end short-description -->


  If you want to sync markdown notes to Anki, here's how to get started!

  1. In Anki, install the [AnkiConnect](https://ankiweb.net/shared/info/2055492159) add-on


  2. Install Memium in its own virtual environment with pipx,

  ```bash
  > pipx install memium
  ```

  3. Import your notes!

  ```cli-block
  > memium --input-dir [YOUR_INPUT_DIR]
  ```


  2. Install [Orbstack](https://orbstack.dev/) or Docker Desktop.
  3. Setup a container
  ```bash
  $INPUT_DIR="PATH_TO_YOUR_INPUT_DIR"

  docker run -i \
    --name=memium \
    -e HOST_INPUT_DIR=$INPUT_DIR \
    -v $INPUT_DIR:/input \
    --restart unless-stopped \
    ghcr.io/martinbernstorff/memium:latest \
    memium \
    --input-dir /input/
  ```

  This will start a docker container which updates your deck from `$INPUT_DIR`. In case of updated files, it will sync the difference (create new prompts and delete deleted prompts) to Anki.

  If you want to continuously sync the directory, set the `--watch-seconds [UPDATE_SECONDS]` argument as well.

  Keeping the package update can be a bit of a chore, which can be automated with [WatchTower](https://github.com/containrrr/watchtower).


  If you would like to build build your own Python application on top of the abstractions added here, you can install the library from pypi:

  ```bash
  pip install memium
  ```


  The library is built as a pipeline illustrated below. Left describes the abstract pipeline, defined by interfaces. The right path describes an implementation of those interfaces from markdown to Anki, which is available in the CLI.

  ```mermaid

  graph TD
  	FD["File on disk"]
          DP["Prompts at Destination"]
  	FD -- DocumentSource --> Document
  	Document -- PromptExtractor --> Prompt
  	Prompt -- Destination --> DP

  	MD["Markdown file"]
  	Prompts["[QAPrompt | ClozePrompt]"]
          Anki["Cards in the Anki app"]

  	MD -- MarkdownDocumentSource --> Document
  	Document -- "[QAPromptExtractor, \nClozePromptExtractor]" --> Prompts
          Prompts -- AnkiConnectDestination --> Anki
   ```



  1. Install [Orbstack](https://orbstack.dev/) or Docker Desktop. Make sure to complete the full install process before continuing.
  2. If not installed, install VSCode
  3. Press this [link](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/MartinBernstorff/memium/)
  4. Complete the setup process


  Feel free to submit pull requests! If you want to run the entire pipeline locally, run:

  ```bash
  inv validate_ci
  ```



  | Type                           |                        |
  | ------------------------------ | ---------------------- |
  | 🚨 **Bug Reports**              | [GitHub Issue Tracker] |
  | 🎁 **Feature Requests & Ideas** | [GitHub Issue Tracker] |
  | 👩‍💻 **Usage Questions**          | [GitHub Discussions]   |
  | 🗯 **General Discussion**       | [GitHub Discussions]   |

  [github issue tracker]: https://github.com/MartinBernstorff/memium/issues
  [github discussions]: https://github.com/MartinBernstorff/memium/discussions


pkgId: f590e31aec34669d2e82e3363ba953e754b84c84cf734cdf2754523a7ba7d619
name: python-mentorhub-flask-utils-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for mentorhub-flask-utils
url: https://github.com/agile-learning-institute/mentorHub-flask-utils
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mentorhub-flask-utils-1.0.1-1.src.rpm
location_href: Packages/python-mentorhub-flask-utils-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This is collection of simple Flask utilities for MentorHub API projects.


  Install the package
  ```sh
  pipenv install mentorhub-flask-utils
  ```


  This is a helper class that allows the flask.json method to properly handle ObjectID and datetime values by converting them to strings.
  ```py
  from flask import Flask
  from mentorhub_flask_utils import MongoJSONEncoder


  app = Flask(__name__)
  app.json = MongoJSONEncoder(app)
  ```

  All API's will be secured with industry standard bearer tokens used to implement Role Based Access Control (RBAC). The create_token method will decode the token and extract claims for a user_id and roles, throwing an exception if the token is not found or not properly encoded.
  ```json
  {
      "user_id": "The users PersonID",
      "roles": ["Staff", "Mentor", "Member"]
  }
  ```
  Valid roles are listed in the mentorhub-mongodb repo's [enumerators file](https://github.com/agile-learning-institute/mentorHub-mongodb/blob/main/configurations/enumerators/enumerators.json) but the roles listed above are the only one's currently used in the mentorHub platform.


  All database collections include a lastModified property that has the following properties:
  ```json
  {
          "atTime": "date-time the document was last modified",
          "byUser": "UserID claim from the access token",
          "fromIp": "IP Address the request originated at",
          "correlationId": "A correlationID to use in logging"
  }
  ```


  Here is how these methods are used in a Flask Route Handler
  ```py
  from mentorhub_flask_utils import create_breadcrumb, create_token
  token = create_token()
  breadcrumb = create_breadcrumb(token)
  MyService.doSomething(myData, ..., token, breadcrumb)
  logger.info(f"Did Something completed successfully {breadcrumb.correlationId}")
  ```





  - [Python](https://www.python.org/downloads/)
  - [Pipenv](https://pipenv.pypa.io/en/latest/installation.html)


  ```bash
  pipenv install --dev
  ```


  ```bash
  pipenv run test
  ```


  ```bash
  pipenv run build
  ```


  ```bash
  pipenv run check
  ```


  You should successfully run ``build`` and ``check`` before publishing.
  ```bash
  pipenv run publish
  ```


pkgId: 0c6775ce61f47c5dbb0dc266cdf205ed90ce6681f6edec611258c96b7b61a36a
name: python-mentorhub-utils-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mentorhub-utils
url: https://github.com/agile-learning-institute/mentorHub-utils
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mentorhub-utils-1.0.0-1.src.rpm
location_href: Packages/python-mentorhub-utils-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  PyPi install
  ```sh
  pipenv install mentorhub-utils
  ```


  These utilities support the mentorHub platform.


  - [Flask Utilities](#flask-utilities)
  - [Config Utilities](#config-utilities)
  - [Mongo Utilities](#mongo-utilities)
  - [Contributing](#contributing)


  This is a collection of simple Flask utilities:
  - MongoJSONEncoder converts ObjectID and datetime values to strings
  - create_token() builds a Roles Based Access Control (RBAC) token
  - create_breadcrumb(token) builds the breadcrumb used when updating the database




   This is a helper class that allows the flask.json method to properly handle ObjectID and datetime values by converting them to strings.
  ```py
  from flask import Flask
  from mentorhub_flask_utils import MongoJSONEncoder


  app = Flask(__name__)
  app.json = MongoJSONEncoder(app)


  from flask import jsonify
  print jsonify(dict)
  ```


   All API's will be secured with industry standard bearer tokens used to implement Role Based Access Control (RBAC). The create_token method will decode the token and extract claims for a user_id and roles, throwing an exception if the token is not found or not properly encoded.
  ```json
  {
      "user_id": "The users PersonID",
      "roles": ["Staff", "Mentor", "Member"]
  }
  ```
  Valid roles are listed in the mentorhub-mongodb repo's [enumerators file](https://github.com/agile-learning-institute/mentorHub-mongodb/blob/main/configurations/enumerators/enumerators.json) but the roles listed above are the only one's currently used in the mentorHub platform.


   All database collections include a lastModified "breadcrumb" property used to track changes over time. The breadcrumb has the following properties:
  ```json
  {
          "atTime": "date-time the document was last modified",
          "byUser": "UserID claim from the access token",
          "fromIp": "IP Address the request originated at",
          "correlationId": "A correlationID to use in logging"
  }
  ```


  Here is how these methods are used in a Flask Route Handler
  ```py
  from mentorhub_flask_utils import create_breadcrumb, create_token
  token = create_token()
  breadcrumb = create_breadcrumb(token)
  MyService.doSomething(myData, ..., token, breadcrumb)
  logger.info(f"Did Something completed successfully {breadcrumb.correlationId}")
  ```


  This is collection of utilities to support API Configuration in a standard way
  - Mentorhub_Config handles configuration values
  - config_routes() is a Flask request handler


  Standard Config


  Standard mental hub configuration values. Configurations are managed in a consistent way favoring file based configuration values, then environment, configuration values, and then default values. See the [Mentorhub_Config.py](./mentorhub_utils/config/MentorHub_Config.py) for details on the configuration values.

  ```py
  config = Mentorhub_Config.get_instance()
  print config.LOGGING_LEVEL
  ```


   This is a simple flask request handler to be used to expose the config data on a config endpoint.
  ```py
  from flask import Flask
  app = Flask(__name__)
  config_handler = create_config_routes()
  app.register_blueprint(config_handler, url_prefix='/api/config')
  ```


  Simple wrappers for MongoIO and a Config Initializer.
  - [get_instance()](#get_instance)
  - [initialize()](#initialize)
  - [configure(enumerators_key)](#configureenumerators_key)
  - [disconnect](#disconnect)
  - [get_documents](#get_documentscollection_name-match-project-order)
  - [get_document](#get_documentcollection_name-string_id)
  - [create_document](#create_documentcollection_name-document)
  - [update_document](#update_documentcollection_name-_id-updates)
  - [delete_document](#delete_documentcollection_name-string_id)




   Get a reference to the Singleton object
  ```py
  mongo_io = MentorHubMongoIO.get_instance()
  ```


   This method will initialize the MongoIO singleton object, connect to the database, and update the Config.versions and Config.enumerators values. You should call this function when initializing the mongodb connection. This method takes as a parameter the primary collection name used to load enumerators.
  ```py
  mongo_io = Mentorhub_MongoIO.get_instance()
  mongo_io.configure(config.MAIN_COLLECTION_NAME)
  ```


   This Method will disconnect from the database in a graceful way. You should call this method when the server process is ending.
  ```py
  mongo_io = MentorHubMongoIO.get_instance()
  mongo_io.disconnect()
  ```


   This is a convenience method to get a list of documents based on Mongo Match, project, and sort order parameters.
  ```py
  match = {"name": {"$regex": query}}
  order = [('name', ASCENDING)]
  project = {"_id":1,"name":1}
  documents = mentorhub_mongoIO.get_documents("COLLECTION_NAME", match, project, order)
  ```

   This is a convenience method to get a single document based on ID
  ```py
  document = mentorhub_mongoIO.get_document("COLLECTION_NAME", "_ID String")
  ```


   This is a convenient method for creating a single document
  ```py
  document = {"foo":"bar"}
  created = mentorhub_mongoIO.create_document("COLLECTION_NAME", document)
  ```


   This is a convenience method for updating a single document based on ID
  ```py
  id = "24-byte-id"
  patch = {"foo":"bar"}
  updated = mentorhub_mongoIO.update_document("COLLECTION_NAME", id, patch)
  ```


   This is a convenience method for deleting a document based on ID. This is an actual live delete, not a soft delete.
  ```py
  id = "24-byte-id"
  updated = mentorhub_mongoIO.delete_document("COLLECTION_NAME", id)
  ```


  If you want to contribute to this library, here are the instructions.



  - [Python](https://www.python.org/downloads/)
  - [Pipenv](https://pipenv.pypa.io/en/latest/installation.html)


  ```bash
  pipenv install --dev
  ```


  ```bash
  pipenv run unit
  ```


  ```bash
  pipenv run test
  ```


  ```bash
  pipenv run clean
  ```


  ```bash
  pipenv run build
  ```


  To check if the package is ready to publish
  ```bash
  pipenv run check
  ```


  You should successfully run ``clean``, ``build`` and ``check`` before publishing.
  ```bash
  pipenv run publish
  ```
  NOTE: You will be prompted for PyPi authentication credentials. You should not need to use the command, it is used by the GitHub Actions CI.


pkgId: 02dbfe23f14a81a4678da5c6e8e2dd547d8361c1f5a7998d7829b8dd5081faf1
name: python-mercury-orm-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for mercury-orm
url: https://github.com/BCR-CX/mercury-orm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mercury-orm-0.1.4-1.src.rpm
location_href: Packages/python-mercury-orm-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Mercury is a Python ORM (Object-Relational Mapping) designed to integrate seamlessly with the Zendesk Custom Objects API. It provides a Django-like interface for defining, managing, and interacting with Zendesk custom objects and records, simplifying the communication with Zendesk's API.



  - **Custom Object Representation**: Define Zendesk custom objects using Python classes.
  - **Automatic Record Management**: Built-in methods for creating, reading, updating, and deleting records via Zendesk's API.
  - **Support for All Field Types**: Compatible with all Zendesk custom field types including text, dropdown, checkbox, date, integer, and more.
  - **Automatic Object Creation**: Automatically create Zendesk custom objects and fields from Python class definitions.
  - **Easy Record Operations**: Simple API to manage custom object records, with built-in support for querying, filtering, and pagination.



  ```bash
  pip install mercury-orm

  export ZENDESK_SUBDOMAIN=<your_zendesk_subdomain>.
  export ZENDESK_API_TOKEN=<your_zendesk_api_token>.
  export ZENDESK_EMAIL=<your_zendesk_email>.
  ```



  Mercury ORM provides simple methods for performing CRUD (Create, Read, Update, Delete) operations on Zendesk custom object records. Below are examples of how to manage records in your custom objects.



  ```
  class Product(CustomObject):
      name = fields.TextField("name")
      code = fields.TextField("code")
      description = fields.TextareaField("description")
      price = fields.DecimalField("price")
      active = fields.CheckboxField("active")
      voltage = fields.DropdownField("voltage", choices=["220", "110", "Bivolt"])
  ```



  Once you define the custom object class, you can create it in Zendesk using ZendeskObjectManager. This will automatically create the custom object and its fields in Zendesk.

  ```
  from mercuryormc.zendesk_manager import ZendeskObjectManager


  manager = ZendeskObjectManager()
  manager.create_custom_object_from_model(Product)

  manager.get_or_create_custom_object_from_model(Product)
  ```


  Each custom object class is automatically assigned a RecordManager that handles interaction with the Zendesk API. The RecordManager allows you to:

  - Create records: ```Product.objects.create(**kwargs)```
  - Get a single record: ```Product.objects.get(id=1)```
  - Filter records: ```Product.objects.filter(active=True)```
  - Delete records: ```Product.objects.delete(id=1)```
  - Retrieve all records: ```Product.objects.all()```
  - Search all records: ```Product.objects.search(word="something")```



  You can create a new record by instantiating your custom object and calling the `save()` method:

  ```python
  product = Product(name="Sample Product", code="12345", price=99.99, active=True)
  product.save()


  Product.objects.create(name="Sample Product", code="12345", price=99.99, active=True)
  ```


  You can retrieve an individual record by using the get() method:
  ```
  retrieved_product = Product.objects.get(id=product.id)
  ```


  To update a record, modify its attributes and call the save() method again:
  ```
  retrieved_product.price = 89.99
  retrieved_product.save()
  ```



  To delete a record from Zendesk, call the delete() method on the object:
  ```
  retrieved_product.delete()
  ```


  You can retrieve all records or filter them based on certain criteria.
  ```
  all_products = Product.objects.all()
  filtered_products = Product.objects.filter(active=True)
  last_object = Product.objects.last()
  ```


pkgId: f4d3aaed904ac9a0bda061afa65ccc0c701070634dacfff64ecb5acf877d2f17
name: python-meshRW-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for meshRW
url: https://github.com/luclaurent/meshRW
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-meshRW-1.2.0-1.src.rpm
location_href: Packages/python-meshRW-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/luclaurent/meshRW?style=flat-square) [![pypi release](https://img.shields.io/pypi/v/meshrw.svg)](https://pypi.org/project/meshrw/) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.14514789.svg)](https://doi.org/10.5281/zenodo.14514789) ![CI-pytest](https://github.com/luclaurent/meshRW/actions/workflows/CI-pytest.yml/badge.svg) ![code coverage](https://raw.githubusercontent.com/luclaurent/meshRW/refs/heads/coverage-badge/coverage.svg)

  <!-- ![GitHub release (latest by date)](https://img.shields.io/github/v/release/luclaurent/meshRW?style=flat-square) ![GitHub all releases](https://img.shields.io/github/downloads/luclaurent/meshRW/total?style=flat-square)  -->

  `meshRW` is a Python module that proposes basic readers and writers for `msh` ([gmsh](http://gmsh.info)) and `vtk/vtu/pvd` ([Paraview](https://www.paraview.org/)). It proposes:

  * to read basic legacy `gmsh` mesh files (version: 2.2)
  * to write mesh files including time series fields to any version of `gmsh` mesh files and legacy (`.vtk`) and XML (`.vtu`, with `.pvd`) VTK mesh file compatible with [Paraview](https://www.paraview.org/).




  Installation via `pip install meshRW`





  Examples of usage could be found in tests files: [`test_msh.py`](meshRW/tests/test_msh.py) and [`test_vtk.py`](meshRW/tests/test_vtk.py).



  `meshRW` can read `msh` files only. Notice that no field can be read.

  * For `msh` format ([only Legacy version 2](http://gmsh.info/doc/texinfo/gmsh.html#MSH-file-format-version-2-_0028Legacy_0029)):

      * Read the file

              from meshRW import msh
              dataMesh = msh.mshReader(filename=<name of the file>, dim=<2 or 3>)

          Argument `dim` (which is optional) could be switched to the value `2` in order to force to extract nodes coordinates in 2D (z-axis coordinate will be removed).

      * Get coordinates of the nodes

               nodes = dataMesh.getNodes()

      * Get the list of tags number

               tags = dataMesh.getTags()

      * Get the list of types of elements

               tags = dataMesh.getTypes()

      * Get the list of elements

               elements = dataMesh.getElements(type=<types of elements>, tag=<tags>, dictFormat=<True or False>)

          The `getElements` property




  `meshRW` can write `msh` and `vtk` files. Basic static and **time dependent** nodal and elemental fields can be written aswell.

  The common syntax for writers is the following

          from meshRW import XXXX

              XXXX.zzzzWriter(
                  filename = <name of the file>,
                  nodes = <array of nodes coordinates>,
                  title = <title of the file> (optional),
                  elements = [
                      {
                          'connectivity': <name of the file>,
                          'type': <type (string) of elements (TRI3, TET4...)>,
                          'physgrp': <list/array of physical groups>,
                      },...
                  ],
                  fields = [
                      {
                          'data': <array of data>,
                          'type': <type of data ('nodal' or 'elemental')>,
                          'dim': <ndimension of data's array>,
                          'name': <name of the field>,
                      },
                      {
                          'data': <array of data>,
                          'type': <name of the file>,
                          'dim': <dimension of data's array>,
                          'name': <name of the field>,
                          'nbsteps': <number of steps (transient field for instance)>,
                          'steps': <list of steps (time steps for instance)>
                          },...
                  ],
                  opts = {...} (dictionary of specific options)
              )

  * For `msh` format (based on [Legacy format, version 2.2](http://gmsh.info/doc/texinfo/gmsh.html#MSH-file-format-version-2-_0028Legacy_0029) only with class `msh` and all meshes format provided by `gmsh` using class `msh2`):

      * for classical legacy file (not use the gmsh's libAPI) could be accessed by choosing `XXXX = msh` and `zzzz=msh` (`msh.mshWriter(...)`)
      * for any kind of  legacy file (not use the gmsh's libAPI) could be accessed by choosing `XXXX = msh2` and `zzzz=msh` (`msh2.mshWriter(...)`)

  **NB:**
  * `filename` must contain `.msh` extension
  * `opts` could be (for `msh2` only) `{'version': VV}` (`VV` could be equal to `2, 2.2, 4, 4.1` that corresponds to `gmsh` mesh files version - `MshFileVersion`)
  * in the case of time series data, all the fields are given by default in the output file (to obtain one field per file, pass option `append = True` to the writer).

  * for `vtk` format ([only non-binary legacy](https://kitware.github.io/vtk-examples/site/VTKFileFormats/))

      * for classical legacy file (not use the VTK library) could be accessed by choosing `XXXX = vtk` and `zzzz=vtk` (`vtk.vtkWriter(...)`)
      * for any kind of  legacy file (not use the gmsh's libAPI) could be accessed by choosing `XXXX = vtk2` and `zzzz=vtk` (`vtk2.vtkWriter(...)`)

  **NB:**
  * `filename` must contain `.vtk`, `.vtu` (recommanded) extension
  * `opts` could be (for `vtk2` only) `{'binary': True/False, 'ascii': True/False}` (these options force data format in `.vtu` files)
  * in the case of time series fields, the fields are written separated series files with the following format : `basename.NNN.vtu` (NNN correspond the number of the step starting at 0). In this case, a [Paraview](https://www.paraview.org/Wiki/ParaView/Data_formats#PVD_File_Format) `.pvd` file is also generated to declare all the steps and associated mesh files with the time step values.



  <!-- ## Examples








  Developments are based on [GMSH API documentation](https://gmsh.info/doc/texinfo/gmsh.html#Gmsh-API), [GMSH tutorials](https://gitlab.onelab.info/gmsh/gmsh/-/tree/master/tutorials/python?ref_type=heads), [VTK documentation](https://vtk.org/doc/nightly/html/index.html), [Kitware blog posts](https://www.kitware.com/blog/), [VTK discourse](https://discourse.vtk.org/).




  * [`meshio`](https://github.com/nschloe/meshio)





  Copyright 2024 luc.laurent@lecnam.net

  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.

rpm_license:
  MIT License  Copyright (c) 2021 luclaurent  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: 02fb7d4b9eee81f8874575ab8387ec8a76a2172254674a081d9b0d01491b6655
name: python-metabolabpy-help
arch: noarch
version: 0.9.64
epoch: 0
release: 1
summary: Development documents and examples for metabolabpy
url: https://github.com/ludwigc/metabolabpy
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metabolabpy-0.9.64-1.src.rpm
location_href: Packages/python-metabolabpy-help-0.9.64-1.noarch.rpm
checksum_type: sha256
description:
  |Version| |Py versions| |Git| |Bioconda| |Build Status (AppVeyor)| |License| |codecov|
  Python package to process 1D and 2D NMR spectroscopic data for metabolomics and tracer based metabolism analysis
  - **Documentation:** https://ludwigc.github.io/metabolabpy
  - **Source:** https://github.com/ludwigc/MetaboLabPy
  - **Bug reports:** https://github.com/ludwigc/MetaboLabPy/issues


pkgId: 82fafcfa916071a56ecd0e3031fcf39b6746398fd49e45b7ffba9ef5dbdcd35f
name: python-metabolabpytools-help
arch: noarch
version: 0.9.64
epoch: 0
release: 1
summary: Development documents and examples for metabolabpytools
url: https://github.com/ludwigc/metabolabpytools
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metabolabpytools-0.9.64-1.src.rpm
location_href: Packages/python-metabolabpytools-help-0.9.64-1.noarch.rpm
checksum_type: sha256
description:
  |Version| |Py versions| |Git| |Bioconda| |Build Status (Travis)| |Build Status (AppVeyor)| |License| |RTD doc| |codecov|
  Python package to process 1D and 2D NMR spectroscopic data for metabolomics and tracer based metabolism analysis
  - **Documentation:** https://ludwigc.github.io/metabolabpy
  - **Source:** https://github.com/ludwigc/MetaboLabPy
  - **Bug reports:** https://github.com/ludwigc/MetaboLabPy/issues


pkgId: 810d69bd2fc3d86c9ff47d7c59ecefee4df2d6e63a8e423e289198519e44d96c
name: python-metabotk-help
arch: noarch
version: 0.1.38
epoch: 0
release: 1
summary: Development documents and examples for metabotk
url: https://pypi.org/project/metabotk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metabotk-0.1.38-1.src.rpm
location_href: Packages/python-metabotk-help-0.1.38-1.noarch.rpm
checksum_type: sha256
description:
  MetabolomicsToolKit (metabotk) is a Python library for working with metabolomics data. It provides a variety of tools and methods for importing, exploring, manipulating and analyzing metabolomics data.

  The library is designed to be easy to use and provides a simple interface for working with metabolomics data. It is also highly extensible and allows users to easily add new methods and tools.




  * Import and export metabolomics data from various sources (e.g. Metabolon) and formats (e.g. excel files, tables)
  * Explore and manipulate metabolomics data
  * Impute missing values
  * Normalize data
  * Perform feature selection and dimensionality reduction
  * Plot data (e.g. metabolite abundance, PCA)




  Install with `pip`:

  ```shell
  pip install metabotk
  ```



  * pandas
  * numpy
  * math
  * scikit-learn
  * seaborn
  * boruta_py for feature selection using Boruta
  * skloess for normalization with LOESS
  * pyserrf for normalization with SERRF




  Metabolomics data requires the following information:

  - Peak values / abundance data for each metabolite over each sample
  - Sample metadata
  - Chemical annotation of the metabolites

  Constantly coordinating these three sources of information is time consuming and prone to errors, especially for explorative analyses.
  Additionally, many analyses are repetitive and can benefit from a standardized procedure. For example, building and plotting a PCA or obtaining statistics about the metabolites/samples is something that is often done before and after modifying or removing data; updating the metadata or statistics after every modification can be automatized.
  With metabotk, the three sources are constantly updated based on changes to the dataset; for example, removing a metabolite or sample from the data will also remove it from the chemical annotation or sample metadata.

  metabotk provides a centralized interface for working with metabolomics data from the first to the last analysis step.

  The following modules constitute metabotk:

  - interface - the main point of access for the end user, with the MetaboTK class; all other modules can be accessed from here
  - dataset manager - the main module for manipulating, importing and saving datasets
  - providers - functions to read data from different providers into metabotk
  - statistics - functions for obtaining statistics at the metabolite or sample level, from mean/std to total sum abundance (TSA) and coefficient of variation (CV), correlations, number of missing or outlier values.
  - dimensionality reduction - functions to perform dimensionality reduction such as PCA
  - imputation - functions to impute missing data
  - normalization - functions to normalize data
  - models - functions to build models from the data (i.e linear models) and remove variable effects
  - feature selection - functions to perform feature selection and identify metabolites discriminating between groups
  - visualization - functions to plot distribution of metabolites, PCA and other kinds of visualization.

  All modules can be extended with different kind of analyses and methods; this is a work in progress aiming to provide a baseline which can be tailored based on the needs of the users.





  !!! Documentation is still a work in progress !!!

  In-depth documentation about each module can be found here:
  https://metabolomics-toolkit.readthedocs.io/en/latest/



  Import the library and initiate the class
  ```shell
  from metabotk import MetaboTK

  dataset = MetaboTK(data_provider="metabolon", sample_id_column='Sample', metabolite_id_column="CHEM_ID",)
  ```
  Import the data in tabular or excel format
  ```shell

  dataset.import_tables(data="data.tsv", sample_metadata="samples.tsv", chemical_annotation="config/metabolites.tsv")


  dataset.import_excel(file_path="dataset.xlsx", sample_metadata = "sample_metadata", chemical_annotation = "chemical_annotation", data_sheet = "peak_data",

  ```
  Get some statistics about the dataset

  ```shell

  sample_stats = dataset.stats.sample_stats()


  metabolite_stats = dataset.stats.metabolite_stats()
  ```
  Get a PCA from the data and plot it

  ```shell
  pca=dataset.dimensionality_reduction.get_pca(n_components=3)

  datset.visualization.plot_pca(pca=pca, hue='treatment')

  ```


pkgId: 075b2a061332734fbaf2e77e8d12aadec910eeb268d5970d97b1ebbe14ed5c44
name: python-metaflow-checkpoint-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for metaflow-checkpoint
url: https://pypi.org/project/metaflow-checkpoint/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metaflow-checkpoint-0.1.6-1.src.rpm
location_href: Packages/python-metaflow-checkpoint-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  Imagine running a machine learning training job or any data processing task that takes hours or even days to complete. In such scenarios, you don't want failures or collaboration complexities to force you to start over and lose all the progress made. **This is where Metaflow's new decorators—`@checkpoint`, `@model`, and `@huggingface_hub`—come into play.** These decorators are specifically designed to address these challenges by simplifying checkpointing, model management, and efficient loading of external models, **ensuring that your long-running jobs can be resumed seamlessly after a failure and that models and checkpoints are properly versioned in multi-user environments.**

  This repository introduces three new decorators for [Metaflow](https://metaflow.org) that address these challenges:

  - **`@checkpoint`**: Simplifies saving and reloading checkpoints within your Metaflow flows.
  - **`@huggingface_hub`**: Enables efficient loading and caching of large models from Hugging Face Hub.
  - **`@model`**: Allows for easy saving and loading of models created during your Metaflow flows.

  Examples for these decorators can be found in [this repository](https://github.com/outerbounds/metaflow-checkpoint-examples/tree/master).





  The `@checkpoint` decorator alleviates the pain points associated with saving and reloading the state of your program (a Metaflow `@step`) in Metaflow flows. It also handles version control in multi-user settings by isolating checkpoints per user and run. Whether it's a checkpoint created by a machine learning model or intermediate data required in case of crashes, this decorator simplifies state management and failure recovery.

  - **Checkpointing**: Save the state of your `@step` at designated points.
  - **Seamless Recovery**: Restart your job from the last checkpoint upon retries without any manual intervention.
  - **User Isolation**: Checkpoints are managed per user to prevent overwriting in collaborative environments.
  - **Ease of Use**: Minimal code changes required to implement checkpointing.



  The `@huggingface_hub` decorator allows you to load large models from Hugging Face Hub and cache them for increased performance benefits. It also ensures that models are versioned and managed appropriately in multi-user environments.

  - **Efficient Model Loading**: Load models on-the-fly from Hugging Face Hub.
  - **Caching Mechanism**: Cache models locally to avoid redundant downloads.
  - **Version Control**: Manages different versions of models to prevent conflicts.
  - **Integration with Metaflow**: Easily incorporate models across your Metaflow flows.



  The `@model` decorator provides a trivial way to save and load models/checkpoints created as part of your Metaflow flow.

  - **Simplified Model Loading**: Automatically load models based on references and identifiers created by decorators such as `@model`/`@checkpoint`/`@huggingface_hub`.
  - **Model Identity**: Associates a uniquie identity to models so that there is clear distinction between different versions making it easy to track their lineage.


pkgId: 7b5999db7c35c088577341f2e1ee4d3a74c0369fcd677218e9bb7cd9fb0c3ddf
name: python-metaflow-dbt-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for metaflow-dbt
url: https://pypi.org/project/metaflow-dbt/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metaflow-dbt-1.0.6-1.src.rpm
location_href: Packages/python-metaflow-dbt-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  This extension adds support for executing DBT models as part of steps in Metaflow Flows via decorators.



  Having a `dbt_project.yml` as part of your Flow project will allow executing `dbt run` as a pre-step to any task by simply adding the decorator to a step.

  ```python
  @dbt
  @step
  def start(self):
      

      self.next(self.second_step)
  ```

  If you only want to run a specific model as part of a step, you can specify this with the `models=` attribute
  ```python
  @dbt(models="customers")
  ```




  You might want to keep the DBT project separately nested within the Flow project. In these cases you would need to specify the location of the DBT project folder, due to the way project lookup works.
  This can be done by specifying the project location as a relative or absolute path within the decorator
  ```python
  @dbt(models="customers", project_dir="./dbt_project")
  ```



  When deploying a DBT flow to be executed remotely, we do not want to bundle up sensitive credentials into the code package. Therefore a plain text `profiles.yml` will not suffice.
  We can utilize the environment variable replacement that DBT offers to get around this.

  example profiles:
  ```python
  dbt_decorator:
    outputs:
      dev:
        type: postgres
        threads: 1
        host: localhost
        port: 5432
        user: "{{ env_var('DBT_POSTGRES_USER') }}"
        pass: "{{ env_var('DBT_POSTGRES_PW') }}"
        dbname: dbt_decorator
        schema: dev_jaffle_schema

      prod:
        type: postgres
        threads: 1
        host: localhost
        port: 5432
        user: "{{ env_var('DBT_POSTGRES_USER') }}"
        pass: "{{ env_var('DBT_POSTGRES_PW') }}"
        dbname: dbt_decorator
        schema: prod_jaffle_schema

    target: dev
  ```

  Note: any profiles.yml in the *flow project folder* will be packaged, so make sure that they do not contain sensitive secrets.

  We can supply the environment variables in various ways, for example
  - having them already present in the execution environment
  - supplying them with the `@environment` decorator in the flow (this still ends up bundling secrets into the package, but is good for testing)
  - hydrating environment variables with the `@secrets` decorator from a secret manager.



  The command `metaflow dbt examples` will pull example flows to your working directory under `metaflow-dbt-examples`.

  Follow the README.md under the examples directory for more instructions.


pkgId: 2589b65883a3dec223be21e6b34ee4d373a08e6f7c5ea001acb83f301abdbf50
name: python-metaflow-help
arch: noarch
version: 2.13
epoch: 0
release: 1
summary: Development documents and examples for metaflow
url: https://pypi.org/project/metaflow/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metaflow-2.13-1.src.rpm
location_href: Packages/python-metaflow-help-2.13-1.noarch.rpm
checksum_type: sha256
description:
  ![Metaflow_Logo_Horizontal_FullColor_Ribbon_Dark_RGB](https://user-images.githubusercontent.com/763451/89453116-96a57e00-d713-11ea-9fa6-82b29d4d6eff.png)



  Metaflow is a human-friendly library that helps scientists and engineers build and manage real-life data science projects. Metaflow was [originally developed at Netflix](https://netflixtechblog.com/open-sourcing-metaflow-a-human-centric-framework-for-data-science-fa72e04a5d9) to boost productivity of data scientists who work on a wide variety of projects from classical statistics to state-of-the-art deep learning.

  For more information, see [Metaflow's website](https://metaflow.org) and [documentation](https://docs.metaflow.org).



  Metaflow provides a simple, friendly API that covers foundational needs of ML, AI, and data science projects:
  <img src="./docs/prototype-to-prod.png" width="800px">

  1. [Rapid local prototyping](https://docs.metaflow.org/metaflow/basics), [support for notebooks](https://docs.metaflow.org/metaflow/visualizing-results), and [built-in experiment tracking and versioning](https://docs.metaflow.org/metaflow/client).
  2. [Horizontal and vertical scalability to the cloud](https://docs.metaflow.org/scaling/remote-tasks/introduction), utilizing both CPUs and GPUs, and [fast data access](https://docs.metaflow.org/scaling/data).
  3. [Managing dependencies](https://docs.metaflow.org/scaling/dependencies) and [one-click deployments to highly available production orchestrators](https://docs.metaflow.org/production/introduction).




  Getting up and running is easy. If you don't know where to start, [Metaflow sandbox](https://outerbounds.com/sandbox) will have you running and exploring Metaflow in seconds.



  To install Metaflow in your local environment, you can install from [PyPi](https://pypi.org/project/metaflow/):

  ```sh
  pip install metaflow
  ```
  Alternatively, you can also install from [conda-forge](https://anaconda.org/conda-forge/metaflow):

  ```sh
  conda install -c conda-forge metaflow
  ```
  If you are eager to try out Metaflow in practice, you can start with the [tutorial](https://docs.metaflow.org/getting-started/tutorials). After the tutorial, you can learn more about how Metaflow works [here](https://docs.metaflow.org/metaflow/basics).


  <img src="./docs/multicloud.png" width="800px">


  While you can get started with Metaflow easily on your laptop, the main benefits of Metaflow lie in its ability to [scale out to external compute clusters](https://docs.metaflow.org/scaling/remote-tasks/introduction)
  and to [deploy to production-grade workflow orchestrators](https://docs.metaflow.org/production/introduction). To benefit from these features, follow this [guide](https://outerbounds.com/engineering/welcome/) to
  configure Metaflow and the infrastructure behind it appropriately.




  An active [community](http://slack.outerbounds.co/) of thousands of data scientists and ML engineers discussing the ins-and-outs of applied machine learning.


  - [Introduction to Metaflow](https://outerbounds.com/docs/intro-tutorial-overview/)
  - [Natural Language Processing with Metaflow](https://outerbounds.com/docs/nlp-tutorial-overview/)
  - [Computer Vision with Metaflow](https://outerbounds.com/docs/cv-tutorial-overview/)
  - [Recommender Systems with Metaflow](https://outerbounds.com/docs/recsys-tutorial-overview/)
  - And more advanced content [here](https://outerbounds.com/docs/tutorials-index/)


  - [Infrastructure Stack for Large Language Models](https://outerbounds.com/blog/llm-infrastructure-stack/)
  - [Parallelizing Stable Diffusion for Production Use Cases](https://outerbounds.com/blog/parallelizing-stable-diffusion-production-use-cases/)
  - [Whisper with Metaflow on Kubernetes](https://outerbounds.com/blog/whisper-kubernetes/)
  - [Training a Large Language Model With Metaflow, Featuring Dolly](https://outerbounds.com/blog/train-dolly-metaflow/)


  There are several ways to get in touch with us:
  - [Slack Community](http://slack.outerbounds.co/)
  - [Github Issues](https://github.com/Netflix/metaflow/issues)


  We welcome contributions to Metaflow. Please see our [contribution guide](https://docs.metaflow.org/introduction/contributing-to-metaflow) for more details.


pkgId: 893bccb2af9348eb102f98f9e26678c894c87a532226a7e299d11e5a2a16978e
name: python-metaflow-stubs-help
arch: noarch
version: 2.13
epoch: 0
release: 1
summary: Development documents and examples for metaflow-stubs
url: https://pypi.org/project/metaflow-stubs/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metaflow-stubs-2.13-1.src.rpm
location_href: Packages/python-metaflow-stubs-help-2.13-1.noarch.rpm
checksum_type: sha256
description:
  This package contains stub files for `metaflow` and thus offers type hints for various editors (such as `VSCode`) and language servers (such as `Pylance`).



  To install Metaflow Stubs in your local environment, you can install from [PyPi](https://pypi.org/project/metaflow-stubs/):

  ```sh
  pip install metaflow-stubs
  ```


pkgId: cc85bd9467646d6b17ca8a3b9977cdc7baec86305abca9625323b972c27bc985
name: python-metis-data-help
arch: noarch
version: 0.6.16
epoch: 0
release: 1
summary: Development documents and examples for metis-data
url: https://pypi.org/project/metis-data/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metis-data-0.6.16-1.src.rpm
location_href: Packages/python-metis-data-help-0.6.16-1.noarch.rpm
checksum_type: sha256
description:
  A set of utility functions and classes to aid in running jobs and libraries on a spark cluster, mostly on
  the Databricks Platform, and targeted at AWS deployments.

  TODO: This is a copy from the old jobworthy repo, and requires tons of updates to match the metis_data API.



  + [Spark Job](docs/job/spark-job.md)
  + Job Configuration



  + Spark Session



  + [The Repo Module](docs/repo/repo.md)



  + [Database and Table](docs/repo/repository.md)



  The Schema module provides functions for building a more abstract definition of a Hive table schema and abstractions
  for creating table, column and cell data which can be provided as the data argument when creating a dataframe.

  + [Table Schema Definition](docs/structure/table-schema.md)


pkgId: 1b6f35cfedd9ba89857f89c82d6e9845b871cb342eb990d6af3f081ac3857278
name: python-metrics_layer-help
arch: noarch
version: 0.12.48
epoch: 0
release: 1
summary: Development documents and examples for metrics_layer
url: https://github.com/Zenlytic/metrics_layer
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metrics_layer-0.12.48-1.src.rpm
location_href: Packages/python-metrics_layer-help-0.12.48-1.noarch.rpm
checksum_type: sha256
description:
  ![Github Actions](https://github.com/Zenlytic/metrics_layer/actions/workflows/tests.yaml/badge.svg)
  [![codecov](https://codecov.io/gh/Zenlytic/metrics_layer/branch/master/graph/badge.svg?token=7JA6PKNV57)](https://codecov.io/gh/Zenlytic/metrics_layer)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  Metrics Layer is an open source project with the goal of making access to metrics consistent throughout an organization. We believe you should be able to access consistent metrics from any tool you use to access data. This metrics layer is designed to work with [Zenlytic](https://zenlytic.com) as a BI tool.



  [Zenlytic](https://zenlytic.com) is the only supported BI tool. The Metrics Layer will read your data model and give you the ability to access those metrics and dimensions in a python client library, or through SQL with a special `MQL` tag.

  Sound interesting? Here's how to set Metrics Layer up with your data model and start querying your metrics in **in under 2 minutes**.



  Make sure that your data warehouse is one of the supported types. Metrics Layer currently supports Snowflake, BigQuery, Postgres, Druid (only SQL compilation, not running the query), DuckDB (only SQL compilation, not running the query), SQL Server (only SQL compilation, not running the query), and Redshift, and only works with `python >= 3.8` up to `python < 3.11`.

  Install Metrics Layer with the appropriate extra for your warehouse

  For Snowflake run `pip install metrics-layer[snowflake]`

  For BigQuery run `pip install metrics-layer[bigquery]`

  For Redshift run `pip install metrics-layer[redshift]`

  For Postgres run `pip install metrics-layer[postgres]`




  There are several ways to set up a profile, we're going to look at the fastest one here.

  The fastest way to get connected is to pass the necessary information directly into Metrics Layer. Once you've installed the library with the warehouse you need, you should be able to run the code snippet below and start querying.

  You'll pull the repo from Github for this example. For more detail on getting set up, check out the [documentation](https://docs.zenlytic.com)!


  ```
  from metrics_layer import MetricsLayerConnection


  config = {
    "location": "https://myusername:myaccesstoken@github.com/myorg/myrepo.git",
    "branch": "develop",
    "connections": [
      {
        "name": "mycompany",              # The name of the connection in your data model (you'll see this in model files)
        "type": "snowflake",
        "account": "2e12ewdq.us-east-1",
        "username": "demo_user",
        "password": "q23e13erfwefqw",
        "database": "ANALYTICS",
        "schema": "DEV",                  # Optional
      }
    ],
  }
  conn = MetricsLayerConnection(**config)


  df = conn.query(metrics=["total_revenue"], dimensions=["channel", "region"])
  ```

  For more advanced methods of connection and more information about the project check out [the docs](https://docs.zenlytic.com).


pkgId: b105369e53ed0a8142272c756f28476ce273d806f445f2e8ecd20e89ab26c425
name: python-metvae-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for metvae
url: https://pypi.org/project/metvae/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metvae-0.0.1-1.src.rpm
location_href: Packages/python-metvae-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  MetVAE is a specialized Python package that implements a Variational Autoencoder (VAE) specifically designed for metabolomics correlation analysis. It addresses key challenges in metabolomics data, especially in untargeted metabolomics, including compositionality, missing values, and the influence of covariates or confounders.



  - **Compositionality-Aware**: Automatically handles compositional data through centered log-ratio (CLR) transformation
  - **Smart Zero Handling**: Uses censored estimation and multiple imputation for values below detection limit
  - **Covariate/Confounder Adjustment**: Removes unwanted variation from experimental and biological covariates or confounders
  - **Sparse Correlation Analysis**: Provides statistical and data-driven methods to construct a sparsified correlation matrix for metabolites
  - **Latent Space Analysis**: Enables exploration of underlying metabolic patterns and modules



  ```bash
  pip install metvae
  ```



  Here's a simple example to get you started:

  ```python
  from metvae import MetVAE


  model = MetVAE(
      data=abundance_data,
      meta=meta_data,
      continuous_covariate_keys=['age', 'bmi'],
      categorical_covariate_keys=['sex', 'batch'],
      latent_dim=10
  )


  model.train(max_epochs=1000)


  correlations = model.get_corr(num_sim=1000)


  sparse_network = model.sparse_by_thresholding(
      th_len=30,
      n_cv=5,
      soft=False
  )
  ```





  The package automatically handles several preprocessing steps:

  1. **CLR Transformation**: Addresses the compositional nature of metabolomics data
  2. **Zero Value Processing**: Uses sophisticated methods to handle measurements below detection limit
  3. **Covariate/Confounder Adjustment**: Removes unwanted variation from known confounding factors



  MetVAE provides multiple approaches for analyzing metabolite relationships:

  ```python

  model.get_corr(num_sim=1000)


  sparse_stats = model.sparse_by_filter(
      p_adj_method='fdr_bh',
      cutoff=0.05
  )


  sparse_thresh = model.sparse_by_thresholding(
      th_len=30,
      n_cv=5
  )
  ```



  Explore the patterns learned by the model:

  ```python

  loadings = model.clr_loading()


  cooccurrence = model.cooccurrence()
  ```





  The package offers two main approaches to network sparsification:

  1. **Statistical Filtering**: Uses Fisher's z-test with multiple testing correction to control false discoveries

     ```python
     sparse_stats = model.sparse_by_filter(
         p_adj_method='fdr_bh',  # Benjamini-Hochberg FDR control
         cutoff=0.05
     )
     ```

  2. **Threshold Optimization**: Uses cross-validation to find optimal sparsity levels
     ```python
     sparse_thresh = model.sparse_by_thresholding(
         th_len=30,  # Number of thresholds to test
         n_cv=5,     # Number of cross-validation folds
         soft=False  # Use hard thresholding
     )
     ```



  MetVAE can adjust for both continuous and categorical covariates:

  ```python
  model = MetVAE(
      data=metabolite_data,
      meta=metadata,
      continuous_covariate_keys=['age', 'bmi'],
      categorical_covariate_keys=['sex', 'batch', 'treatment'],
      latent_dim=10
  )
  ```



  The MetVAE package provides a command-line interface for easy model training and analysis. Here's an example showing how to train a model with both continuous and categorical covariates:

  ```bash
  metvae-cli \
  --data test_data.csv \
  --meta test_smd.csv \
  --continuous_covariate_keys x1 \
  --categorical_covariate_keys x2 \
  --latent_dim 100 \
  --use_gpu \
  --logging \
  --batch_size 100 \
  --learning_rate 0.01 \
  --alpha_grid 0 0.0001
  ```

  For a complete list of available parameters and their descriptions, run:

  ```bash
  metvae-cli --help
  ```



  - **Data Format**: Expects pandas DataFrames with samples as either rows or columns
  - **Missing Values**: Automatically handles zero values through sophisticated imputation
  - **GPU Support**: Optional GPU acceleration for model training
  - **Parallel Processing**: Supports multi-core processing for computational efficiency



  This example demonstrates how to implement MetVAE utilizing a synthetic dataset.



  ```python
  import random
  import numpy as np
  import pandas as pd
  import torch
  from metvae.model import MetVAE
  from metvae.sim import sim_data


  n, d, zero_prop, seed = 100, 50, 0.3, 123






  cor_pairs = int(0.2 * d)     # Number of correlated feature pairs (20% of features)
  mu = list(range(10, 15))     # Mean values for data generation
  da_prop = 0.1                # Differential abundance proportion


  np.random.seed(seed)
  smd = pd.DataFrame({
      'x1': np.random.randn(n),                           # Continuous covariate
      'x2': np.random.choice(['a', 'b'], size=n, replace=True)  # Categorical covariate
  })
  smd.index = ["s" + str(i) for i in range(n)]


  sim = sim_data(n=n, d=d, cor_pairs=cor_pairs, mu=mu, x=smd,
                 cont_list=['x1'], cat_list=['x2'], da_prop=da_prop)
  y = sim['y']           # Original absolute abundance data
  x = sim['x']           # Covariates
  true_cor = sim['cor_matrix']  # True correlation matrix
  beta = sim['beta']     # True regression coefficients


  log_y = np.log(y)
  log_sample_bias = np.log(np.random.uniform(1e-3, 1e-1, size=n))    # Sample-specific bias
  log_feature_bias = np.log(np.random.uniform(1e-1, 1, size=d))      # Feature-specific bias
  log_data = log_y + log_sample_bias[:, np.newaxis]
  log_data = log_data + log_feature_bias.reshape(1, d)
  data = np.exp(log_data)


  thresholds = np.quantile(data, zero_prop, axis=0)
  data_miss = np.where(data < thresholds, 0, data)
  data_miss = pd.DataFrame(data_miss, index=y.index, columns=y.columns)
  ```



  ```python

  torch.manual_seed(123)
  np.random.seed(123)
  max_epochs = 1000
  learning_rate = 1e-2


  model = MetVAE(data=data_miss,
                 features_as_rows=False,
                 meta=smd,
                 continuous_covariate_keys=['x1'],
                 categorical_covariate_keys=['x2'],
                 latent_dim=min(n, d))


  model.train(batch_size=100,
              num_workers=0,
              max_epochs=max_epochs,
              learning_rate=learning_rate,
              log_every_n_steps=1)


  model.get_corr(num_sim=1000)
  results_metvae = model.sparse_by_filter(p_adj_method='fdr_bh', cutoff=0.05)
  est_cor = results_metvae['sparse_estimate']


  true_idx = true_cor[np.tril_indices_from(true_cor, k=-1)] != 0
  est_idx = est_cor[np.tril_indices_from(est_cor, k=-1)] != 0
  tpr = np.sum(est_idx & true_idx) / np.sum(true_idx)      # True Positive Rate
  fpr = np.sum(est_idx & ~true_idx) / np.sum(~true_idx)    # False Positive Rate
  fdr = np.sum(est_idx & ~true_idx) / np.sum(est_idx)      # False Discovery Rate


  random.seed(123)
  results_metvae = model.sparse_by_thresholding(th_len=100, n_cv=5, soft=False, n_jobs=1)
  est_cor = results_metvae['sparse_estimate']


  true_idx = true_cor[np.tril_indices_from(true_cor, k=-1)] != 0
  est_idx = est_cor[np.tril_indices_from(est_cor, k=-1)] != 0
  tpr = np.sum(est_idx & true_idx) / np.sum(true_idx)
  fpr = np.sum(est_idx & ~true_idx) / np.sum(~true_idx)
  fdr = np.sum(est_idx & ~true_idx) / np.sum(est_idx)
  ```



  ```python

  tpr =  0.9
  fpr =  0.0
  fdr =  0.0


  tpr =  0.9
  fpr =  0.0
  fdr =  0.0
  ```



  If you use MetVAE in your research, please cite:

  [Paper in Preparation]



  We welcome contributions! Please feel free to submit a Pull Request.



  This package is licensed under the MIT License - see the LICENSE file for details.



  Huang Lin

  Email: hlin1239@umd.edu

  GitHub: https://github.com/FrederickHuangLin/MetVAE-PyPI/issues


pkgId: 20e5e3d343fe9b8f0daa8b95822df787a6331b62d8bf65ca94b22305c517e52e
name: python-mi-libreria-matematica-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mi-libreria-matematica
url: https://github.com/tuusuario/mi_libreria_matematica
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mi-libreria-matematica-0.1.0-1.src.rpm
location_href: Packages/python-mi-libreria-matematica-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Una librería de Python para realizar operaciones matemáticas básicas.



  ```bash
  pip install mi_libreria_matematica
  ```



  ```python
  from mi_libreria_matematica import sumar, restar, multiplicar, dividir

  print(sumar(2, 3))         # 5
  print(restar(5, 2))        # 3
  print(multiplicar(3, 4))   # 12
  print(dividir(8, 2))       # 4.0
  ```




  Primero, asegúrate de tener `build` y `twine`:

  ```bash
  pip install build twine
  ```




  Primero, asegúrate de tener `build` y `twine`:

  ```bash
  pip install build twine
  ```


  ```bash
  python -m build
  ```

  Esto generará archivos en la carpeta dist/:
  ```
  dist/
  ├── mi_libreria_matematica-0.1.0.tar.gz
  └── mi_libreria_matematica-0.1.0-py3-none-any.whl
  ```



  ```bash
  twine upload dist/*
  ```

  Una vez subida a PyPI, cualquier persona (o tú mismo) podrá instalarla usando:

  ```bash
  pip install mi_libreria_matematica
  ```


pkgId: 1cd720d57adbc4afeea26476155884204c577ffbe283f231ab326c6fe99a0868
name: python-micofam-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for micofam
url: https://gitlab.com/dlr-sy/micofam
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-micofam-1.1.0-1.src.rpm
location_href: Packages/python-micofam-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/micofam?label=PyPi)](https://pypi.org/project/micofam)
  [![doi](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.14354356-red.svg)](https://zenodo.org/records/14354356)


  MiCoFaM (Micromechanical Composite Fatigue Modeler) is a model generator for creating representative volume elements (RVEs) consisting of fibre, interface and matrix phases for a given fiber volume content with randomized fiber placements. The application is provided as an ABAQUS plug-in.

  Use GIT to get the latest code base. From the command line, use
  ```
  git clone https://gitlab.dlr.de/dlr-sy/micofam micofam
  ```
  If you check out the repository for the first time, you have to initialize all submodule dependencies first. Execute the following from within the repository.
  ```
  git submodule update --init --recursive
  ```
  To fetch all refererenced submodules, use
  ```
  git submodule foreach --recursive 'git checkout $(git config -f $toplevel/.gitmodules submodule.$name.branch || echo main)'
  ```
  To update all refererenced submodules to the latest production level, use
  ```
  git submodule foreach --recursive 'git pull origin $(git config -f $toplevel/.gitmodules submodule.$name.branch || echo main)'
  ```

  MiCoFaM can be installed and updated directly using [pip](https://pypi.org/project/micofam/). Use
  ```
  pip install micofam
  ```
  to install the latest release. Alternatively,
  MiCoFaM can be installed from source using [poetry](https://python-poetry.org). If you don't have [poetry](https://python-poetry.org) installed, run
  ```
  pip install poetry --pre --upgrade
  ```
  to install the latest version of [poetry](https://python-poetry.org) within your python environment. Use
  ```
  poetry update
  ```
  to update all dependencies in the lock file or directly execute
  ```
  poetry install
  ```
  to install all dependencies from the lock file. Last, you should be able to import MiCoFaM as a python package.
  ```python
  import micofam
  ```

  Navigate to the local ./config folder and execute ABAQUS using
  ```
  abaqus cae
  ```
  ABAQUS CAE is now started with a modified plugin central directory already set. Alternatively, after installing the software through pip, display all available commands by using
  ```console
  $ micofam --help
  usage: MiCoFaM [-h] [-v] {info,start} ...

  CLI commands for MiCoFaM.

  positional arguments:
    {info,start}
      info         Show the current version and system information.
      start        Launch MiCoFaM on the current system. Starts ABAQUS in the process by default.

  options:
    -h, --help     show this help message and exit
    -v, --version  show program's version number and exit
  ```
  To launch the current software with a non-default graphical user interface backend, append a valid identifier to the start command. The backend `abaqus` if set by default.
  ```console
  $ micofam start --help
  usage: MiCoFaM start [-h] ...

  positional arguments:
    backend     Backend application to start MiCoFaM. Defaults to abaqus.

  options:
    -h, --help  show this help message and exit
  ```
  For example, to start [MiCoFaM](https://gitlab.dlr.de/dlr-sy/micofam) with a `abq2023h5`, use
  ```
  micofam start abq2023h5
  ```

  * [Marc Garbade](mailto:marc.garbade@dlr.de)
  * [Caroline Lüders](mailto:caroline.lueders@dlr.de)

  * [List of Contributors](CONTRIBUTING.md)


pkgId: 3a66da20e3e4f22f0c35b09e185a92265b23c1e9702336ecc6fe0a7fc4cb9656
name: python-micro-trainer-transformers-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for micro-trainer-transformers
url: https://github.com/utrobinmv/micro_trainer_transformers
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-micro-trainer-transformers-0.1.6-1.src.rpm
location_href: Packages/python-micro-trainer-transformers-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  Micro version train modules Transformers trainer....

  Микро версия тренировочного модуля библиотеки transformers реализованная, на уровне pytorch-lightning


pkgId: c4112bca860c3d9b960e0dc3976ad2362671e47906acf80f1338a0c1c8366296
name: python-microcotb-help
arch: noarch
version: 0.7.6
epoch: 0
release: 1
summary: Development documents and examples for microcotb
url: https://microcotb.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-microcotb-0.7.6-1.src.rpm
location_href: Packages/python-microcotb-help-0.7.6-1.noarch.rpm
checksum_type: sha256
description:
  Copyright &copy; 2024 Pat Deegan [psychogenic.com](https://psychogenic.com)

  How do you get hardware-in-the-loop with [cocotb](https://cocotb.org)?  This is one, perhaps weird, answer to that that allows you to run [the very same set of tests, like these](https://github.com/psychogenic/microcotb/tree/main/src/examples/common):

    * right in an RP2040, like on the [tinytapeout demoboards](https://github.com/TinyTapeout/tt-micropython-firmware), or any microcontroller that can do [micropython](https://micropython.org/);

    * on a [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/) connected to the DUT;

    * on the desktop, but talking to projects **on an FPGA** that can be connected to external hardware, over USB; or

    * on the desktop, talking to projects on **any external chip**, *through* an FPGA over USB



  This library will run on an [RP2040](https://www.raspberrypi.com/products/rp2040/) and really anything that runs [micropython](https://www.micropython.org/) or full [Python](https://www.python.org/).

  It will also run on the desktop--but then so will cocotb, so what's the point?  The point is getting a simplified manner of extending things to **talk to real hardware**.  See [simple_usb_bridge](https://github.com/psychogenic/microcotb/tree/main/src/microcotb_sub/README.md) for an example of using a USB bridge to an FPGA.

  I've used this to get deep inspection VCD waveforms from modules in FPGAs while they run tests and actually interact with external 3rd party hardware, like the SPI flash being read here

  ![VCD of SPI flash FIFO](https://raw.githubusercontent.com/psychogenic/microcotb/refs/heads/main/images/psyreader_vcd_from_fpga.png)


  The backend will do whatever you want--run on the RP2040 directly, or talk over a serial connection or USB or ethernet, etc.  Whereas the front end provides a cocotb v2 compatible way to detect and run `@cocotb.test()` units just like you did during simulation, *without modifying them*.

  You can

    * start multiple clocks

    * have @cocotb.test()s with attributes like skip, expect_error, timeout_*

    * await on ClockCycles, Timer, RisingEdge, FallingEdge

  and do most of the usual cocotb things.

  One thing it cannot do is inspect _internals_ of an external DUT: when you're only connected to I/O, you can't see what's happening inside and it's a black box.  However, one of the [use cases, the FPGA tb](https://github.com/psychogenic/microcotb/tree/main/src/examples/fpga_tb) actually lets you play out in the world but also monitor deep internal state of a design.


  For example

  ```
  @cocotb.test()
  async def test_counter(dut):
      dut._log.info("Start")

      clock = Clock(dut.clk, 10, units="us")
      cocotb.start_soon(clock.start())

      dut.ui_in.value = 0b1
      dut.rst_n.value = 0
      await ClockCycles(dut.clk, 10)
      dut.rst_n.value = 1
      await ClockCycles(dut.clk, 1)

      dut._log.info("Testing counter")
      for i in range(256):
          assert dut.uo_out.value == dut.uio_out.value, f"uo_out != uio_out"
          assert int(dut.uo_out.value) == i, f"uio value not incremented correctly {dut.uio_out.value} != {i}"
          await ClockCycles(dut.clk, 1)
      dut._log.info("test_counter passed")

  @cocotb.test()
  async def test_edge_triggers(dut):
      dut._log.info("Start")

      clock = Clock(dut.clk, 10, units="us")
      cocotb.start_soon(clock.start())

      dut.ui_in.value = 0b1
      dut.rst_n.value = 0
      await ClockCycles(dut.clk, 10)
      dut.rst_n.value = 1
      await ClockCycles(dut.clk, 1)

      dut._log.info(f"Testing counter, waiting on rising edge of bit 5 at {get_sim_time('us')}us")
      await RisingEdge(dut.some_bit)
      dut._log.info(f"Got rising edge, now {get_sim_time('us')}us value is {hex(dut.uo_out.value)}")

      dut._log.info(f"Now await falling edge")
      await FallingEdge(dut.some_bit)
      dut._log.info(f"Got rising edge, now {get_sim_time('us')}us value is {hex(dut.uo_out.value)}")

      dut._log.info("test_edge_triggers passed")
  ```

  This is from the [tiny tapeout factory test design](https://github.com/TinyTapeout/tt-micropython-firmware/blob/v2.0-dev/src/examples/tt_um_factory_test/tt_um_factory_test.py).  You'll find more examples in the [examples directory there](https://github.com/TinyTapeout/tt-micropython-firmware/blob/v2.0-dev/src/examples/).

  Though not quite as pretty as full cocotb, the tests output logging as usual and provide a summary after the full run

  ![cocotb test run](https://raw.githubusercontent.com/psychogenic/microcotb/refs/heads/main/images/ucocotb-run.png)







  With [cocotb](https://cocotb.org), you can test your hardware design while interacting with a simulator.  The website mentions that "interfacing with existing infrastructure is easy. Do you want to talk to a golden model in your testbench? Or to real hardware, e.g. an FPGA or a logic analyzer?"

  But the solution to getting our ASIC projects into the loop were pretty involved.  Rather than recreate a "simulator" which provides a whole VPI API that cocotb can interact with, this code was developped to instead make bringing in the testbench onto the demo boards easy.




  A simple USB bridge was created to run tests on the desktop but control real hardware over USB, either

   * projects running on an FPGA, wrapped in a SUB layer to expose the I/O over USB; or

   * external chips, wired to an FPGA with a suitable SUB wrapper to translate USB commands to I/O

  More details on this in the [SUB section](https://github.com/psychogenic/microcotb/tree/main/src/microcotb_sub).



  [All the examples](https://github.com/TinyTapeout/tt-micropython-firmware/tree/v2.0-dev/src/examples) from the Tiny Tapeout SDK run cocotb tests on the RP2040 and interact with actual projects on the ASICs.  These were ported in from those used during Verilog development of the projects, and remain mostly as-is.


  Using the [SUB](https://github.com/psychogenic/microcotb/tree/main/src/microcotb_sub), to talk to projects through an FPGA over USB (either within the FPGA or an external chip *through* the FPGA) things are slower than in desktop sim, but still 10x faster than on the RP2040.


  On the Pico, tests run successfully but, since we are manually toggling the clock(s) behind the scenes from [micropython](https://micropython.org/) SDK, the cost of one step is pretty expensive.

  A "step" has a duration of 1/2 the (fastest) started clock's period, in simulator time.  On the RP2040, in real time this one step winds up consumming about 1.6ms.

  So, if the simulation had a 1MHz clock and is waiting on a Timer for 1 ms, that will be 1000 clock cycles, or 2000 times the clock signal is toggled, i.e. steps.  Hence, you'll be waiting on this chunk of simulation to complete for over 3 seconds.

  On the desktop, a single step is much faster--on the order of 6us on my machine right now, so the same sim would only take about 13ms.  The bottleneck on desktop will always be the hardware bridge you are interacting with to control and observe the hardware, whether its libiio, SWV, plain old serial or whatever.






  Get it and use it from github, by cloning or from a release, or on the desktop you can do

  ```
  pip install microcotb
  ```

  This gives you the libraries but head to the repo for [the example tests and code](https://github.com/psychogenic/microcotb/tree/main/src/examples/)


  To get started you need three things:

    1) a set of @cocotb.test()

    2) a way to interact with your hardware from python

    3) an DUT type that translates reads and writes to signals to the actual hardware

    4) an instance of the DUT and to call the runner


  To dive right in can see a [loopback/counter demo](https://github.com/psychogenic/microcotb/tree/main/src/examples/dummy/tb.py) you can run right now by doing

  ```
  $ python examples/dummy/tb.py
  ...
  [20] runner *** Summary ***
  [30] runner     result                                           sim time        real time       error
  [30] runner     PASS    test_loopback                            2.5900ms        0.0074s
  [30] runner     PASS    test_counter                             1.0400ms        0.0025s
  [30] runner     PASS    test_edge_triggers                       665.0000us      0.0021s
  [30] runner     PASS    test_should_fail                         0.0000ns        0.0003s Failed as expected
  [30] runner     SKIP    test_will_skip                           --
  [30] runner     PASS    tmout/t=50/clk_period=12                 54.0000us       0.0003s
  [30] runner     PASS    tmout/t=50/clk_period=10                 50.0000us       0.0003s
  [30] runner     PASS    tmout/t=50/clk_period=60                 60.0000us       0.0002s
  [40] runner     FAIL    tmout/t=100/clk_period=12                102.0000us      0.0003s Timeout at 102.0000us
  [40] runner     FAIL    tmout/t=100/clk_period=10                100.0000us      0.0003s Timeout at 100.0000us
  [40] runner     FAIL    tmout/t=100/clk_period=60                120.0000us      0.0003s Timeout at 120.0000us
  [40] runner     FAIL    tmout/t=200/clk_period=12                102.0000us      0.0004s Timeout at 102.0000us
  [40] runner     FAIL    tmout/t=200/clk_period=10                100.0000us      0.0003s Timeout at 100.0000us
  [40] runner     FAIL    tmout/t=200/clk_period=60                120.0000us      0.0002s Timeout at 120.0000us
  [30] runner     PASS    test_timer                               1.0000ms        0.0061s
  [20] runner Real run time: 0.0217s (355082330.16 steps/s avg)
  ```

  On the desktop, it's blazingly fast.  On uPython, not as much, but it runs, here the [factory test project tb](https://github.com/TinyTapeout/tt-micropython-firmware/blob/v2.0-dev/src/examples/tt_um_factory_test/tt_um_factory_test.py)

  ```
  >>> test.run()


  runner: *** Summary ***
  runner:         result                                           sim time        real time       error
  runner:         PASS    test_loopback                            2.6600ms        2.0000s
  runner:         PASS    test_timeout/timer_t=101/clk_period=10   100.0000us      0.0000s Failed as expected
  runner:         PASS    test_timeout/timer_t=101/clk_period=125  125.0000us      0.0000s Failed as expected
  runner:         PASS    test_timeout/timer_t=200/clk_period=10   100.0000us      0.0000s Failed as expected
  runner:         PASS    test_timeout/timer_t=200/clk_period=125  125.0000us      0.0000s Failed as expected
  runner:         PASS    test_should_fail                         0.0000ns        0.0000s Failed as expected
  runner:         PASS    test_counter                             2.6800ms        3.0000s
  runner:         PASS    test_edge_triggers                       744.9999us      1.0000s
  runner:         SKIP    test_will_skip                           --
  runner: Real run time: 6.0000s (122222.22 steps/s avg)

  ```



  The main delta here are the libraries included--different name, 'cause different project but doing something like

  ```
  import microcotb as cocotb
  from microcotb.clock import Clock
  from microcotb.triggers import RisingEdge, FallingEdge, ClockCycles, Timer
  from microcotb.utils import get_sim_time

  @cocotb.test()
  async def test_loopback(dut):

  ```




  The cocotb tests should work pretty much as-is (and if not, get in touch).

  So a set of things like

  ```
  @cocotb.test(timeout_time=100, timeout_unit='us')
  async def test_timeout(dut):
      clock = Clock(dut.clk, 10, units="us")
      cocotb.start_soon(clock.start())

      await reset(dut)
      await RisingEdge(dut.is_ready)
  ```


  Should get you going without much further change to the tests, because all the class names just map.



  You'll need some manner of getting and setting signals from the hardware.

  This could be directly accessed via micropython, as is the case with Tiny Tapeout.  Or it could be over serial, through JTAG, whatever.

  For TT demoboards, other than the clock and reset, we have 3 8-bit I/O ports.  It looks [like this](https://github.com/TinyTapeout/tt10-verilog-template/blob/main/src/project.v), in verilog.  One of those is bidirectional, so it's split into _in and _out:

    * ui_in

    * uo_out

    * uio_in

    * uio_out


  So we've got low-level micropython.native accessors
  [like these](https://github.com/TinyTapeout/tt-micropython-firmware/blob/v2.0-dev/src/ttboard/util/platform.py#L114)

  With read_bidir_byte, write_bidir_byte etc in hand, we have a way to communicate with the hardware and get/set the signals.



  The DUT--device under test--here will need to be created to expose the right interface, in a way that actually gets/sets the hardware.

  This library includes a [DUT base class](https://github.com/psychogenic/microcotb/blob/main/src/microcotb/dut.py#L82) for these, which provides some helper functions, setup the *_log* and things like that.

  In order for the DUT to be well behaved in your tests, it needs to provide the same interface as it would in cocotb, namely that you play with `dut.attrib.value` a lot.


  The Tiny Tapeout DUT implementation looks something like this:

  ```

  class PinWrapper:
      '''
         give bare pins a .value we can assign to
      '''
      def __init__(self, pin):
          self._pin = pin

      @property
      def value(self):
          return self._pin.value()

      @value.setter
      def value(self, set_to:int):
          if self._pin.mode != Pins.OUT:
              self._pin.mode = Pins.OUT
          self._pin.value(set_to)

  class DUT(microcotb.dut.DUT):
      '''
          Tiny Tapeout DUT, providing ui_in, uo_out, and uio_(in|out)
      '''
      def __init__(self, name:str='DUT'):

          
          self.tt = DemoBoard.get()

          
          self.clk = PinWrapper(self.tt.clk)
          self.rst_n = PinWrapper(self.tt.rst_n)
          self.ena = NoopSignal(1) # does nothing

          port_defs = [
              ('uo_out',  8, platform.read_output_byte, None),
              ('ui_in',   8, platform.read_input_byte, platform.write_input_byte),
              ('uio_in',  8, platform.read_bidir_byte, platform.write_bidir_byte),
              ('uio_out', 8, platform.read_bidir_byte, None)
              ]
          for p in port_defs:
              self.add_port(*p)

  ```

  With that DUT, we can run all the TT tests.  It's using wrappers and the `add_port()` method to expose everything in a way that will both interact with the real hardware and go through all the cocotb tests.



  Once you have all the above, simply running

  ```
      import microcotb as cocotb
      dut = DUT()
      runner = cocotb.get_runner()
      runner.test(dut)
  ```

  will do it's thing.







  The `cocotb.test` decorator will make the decorated function part of the test bench

  It can be used without parameters, e.g.
  ```
  @cocotb.test()
  async def test_clocking(dut):
      dut._log.info("Start")

      clock = Clock(dut.clk, 10, units='us')
      cocotb.start_soon(clock.start())

      await Timer(100, 'us')
  ```

  The following parameters are supported:

    * name (str), to override default name

    * skip (boolean), to skip the test

    * timeout_time (float) and timeout_unit (str), to support timing out

    * expect_fail (boolean), when true, passes on exceptions raised (fail otherwise)


  An example:

  ```
  @cocotb.test(name='timing out', timeout_time=100, timeout_unit='us')
  async def test_timeout(dut):
      clock = Clock(dut.clk, 10, units="us")
      cocotb.start_soon(clock.start())
      await Timer(300, 'us')
  ```

  This test has a timeout set, and awaits too long.  Run like this, the report will show

  ```
      FAIL    timing out      Timeout at <TimeValue 100000 ns>
  ```

  With `expect_fail=True`, you'd get

  ```
      PASS    timing out      Failed as expected
  ```
  instead.



  The equivalent of looping tests with different parameters may be acheived using `cocotb.parametrize`.

  To use this,

    * augment the test definition with parameters

    * specify values to use in cocotb.parametrize()


  With a test like:

  ```
  @cocotb.test(timeout_time=100, timeout_unit='us')
  @cocotb.parametrize(
      t=[50, 100, 200],
      clk_period=[12, 10, 60])
  async def test_timeout(dut, t:int, clk_period:int):
      clock = Clock(dut.clk, clk_period, units="us")
      cocotb.start_soon(clock.start())
      if t >= 200:
          dut._log.warn(f'Test should FAIL...')
      else:
          dut._log.info(f'Test should pass...')

      await Timer(t, 'us')

  ```

  You'll get a test run for all combinations of parameters (so 3*3 = 9 test runs in this example).

  The output will provide the parameters used for each run, like

  ```
      PASS    timing out/t=50/clk_period=12
      PASS    timing out/t=50/clk_period=10
      PASS    timing out/t=50/clk_period=60
      PASS    timing out/t=100/clk_period=12
      PASS    timing out/t=100/clk_period=10
      PASS    timing out/t=100/clk_period=60
      FAIL    timing out/t=200/clk_period=12  Timeout at <TimeValue 102000 ns>
      FAIL    timing out/t=200/clk_period=10  Timeout at <TimeValue 100000 ns>
      FAIL    timing out/t=200/clk_period=60  Timeout at <TimeValue 120000 ns>
  ```

  You can also use tuples for the parameters, rather than keyword arguments

  ```
  @cocotb.test(timeout_time=100, timeout_unit='us')
  @cocotb.parametrize(
      ('t', [50, 100, 200]),
      ('clk_period', [12, 10, 60])
  )
  ```

  would be equivalent to the above.



  As mentioned, the DUT instance needs to be able to both talk with the hardware behind the scenes and to act like the cocotb dut.

  If you are simply exposing the pins and ports, doing something like the sample above will work fine.

  There are cases where tests you have are safe, in that they do not access any internals of the design, but you've added convenience functionality or renaming to the verilog tb, and your cocotb tests reflect that.

  For example, [my old neptune testbench](https://github.com/psychogenic/tt04-neptune/blob/main/src/tb.v) looks like this in verilog


  ```

  // testbench is controlled by test.py
  module tb (
      input [2:0] clk_config,
      input input_pulse,
      input display_single_enable,
      input display_single_select,
      output [6:0] segments,
      output prox_select
      );

      // this part dumps the trace to a vcd file that can be viewed with GTKWave
      initial begin
          $dumpfile ("tb.vcd");
          $dumpvars (0, tb);
          
      end

      // wire up the inputs and outputs
      reg  clk;
      reg  rst_n;
      reg  ena;
      // reg  [7:0] ui_in;
      reg  [7:0] uio_in;
      wire [7:0] uo_out;
      wire [7:0] uio_out;
      wire [7:0] uio_oe;

      assign prox_select = uo_out[7];
      assign segments = uo_out[6:0];

      wire [7:0] ui_in = {display_single_select,
                          display_single_enable,
                          input_pulse,
                          clk_config[2], clk_config[1], clk_config[0],
                          1'b0,1'b0};

     /* ... */
  ```

  and my cocotb tests use the nicely named `input_pulse` (a bit), `clk_config` (3 bits), etc.

  The first option would be to re-write all the cocotb.test() stuff to use only ui_in and such.  Yuk.

  Rather than do all that work, and have ugly `tt.ui_in.value[5]` stuff everywhere as a bonus, you can extend the DUT class to add in wrappers to these values.

  To do this, you just derive a new class from `microcotb.dut.DUT`, create the attributes using `new_bit_attribute` or `new_slice_attribute` (for things like `tt.ui_in[3:1]`).

  In my neptune case, this looks like:

  ```


  import ttboard.cocotb.dut

  class DUT(ttboard.cocotb.dut.DUT):
      def __init__(self):
          super().__init__('Neptune')
          self.tt = DemoBoard.get()
          
          self.display_single_select = self.new_bit_attribute(self.tt.ui_in, 7)
          self.display_single_enable = self.new_bit_attribute(self.tt.ui_in, 6)
          self.input_pulse = self.new_bit_attribute(self.tt.ui_in, 5)
          self.clk_config = self.new_slice_attribute(self.tt.ui_in, 4, 2) # tt.ui_in[4:2]
          
          self.prox_select = self.new_bit_attribute(self.tt.uo_out, 7)
          self.segments = self.new_slice_attribute(self.tt.uo_out, 6, 0) # tt.uo_out[6:0]
  ````

  Using that class to construct my dut, things like

  ```

      pulseClock = Clock(dut.input_pulse, 1000*(1.0/tunerInputFreqHz), units='ms')
      cocotb.start_soon(pulseClock.start())
      
      val = int(dut.segments.value) << 1
  ```

  will justwork(tm) in the tests.





  More info and some demonstrations coming shortly, keep an eye out here and on [my youtube channel](https://www.youtube.com/@PsychogenicTechnologies).




  This library is release under the LGPL.  See the LICENSE files for details.
  Certain portions were adapted from [cocotb](https://cocotb.org) (namely found in microcotb.types) to run on uPython and extend them, and are

  Copyright cocotb contributors

  and under the

  Licensed under the Revised BSD License, see LICENSE for details.
  SPDX-License-Identifier: BSD-3-Clause

  See individual files.


pkgId: c1807ac44ae41e55e93a37e8d2665664646a39a4c3a2a8d9f40c619a61ddbff7
name: python-microfilm-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for microfilm
url: https://github.com/guiwitz/microfilm
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-microfilm-0.3.0-1.src.rpm
location_href: Packages/python-microfilm-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/guiwitz/microfilm/master?urlpath=lab)
  [![build](https://github.com/guiwitz/microfilm/actions/workflows/test_build.yml/badge.svg)](https://github.com/guiwitz/microfilm/actions/workflows/test_build.yml)
  ![PyPI - License](https://img.shields.io/pypi/l/microfilm)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/microfilm)
  ![PyPI](https://img.shields.io/pypi/v/microfilm)
  ![PyPI - Status](https://img.shields.io/pypi/status/microfilm)


  This package is a collection of tools to display and analyze 2D and 2D time-lapse microscopy images. In particular it makes it straightforward to create figures containing multi-channel images represented in a *composite* color mode as done in the popular image processing software [Fiji](https://imagej.net/software/fiji/). It also allows to easily complete such figures with standard annotations like **labels** and **scale bars**. In case of time-lapse data, the figures are turned into **animations** which can be interactively browsed from a Jupyter notebook, saved in standard movie formats (mp4, gif etc.) and completed with **time counters**. Finally, figures and animations can easily be combined into larger **panels**. These main functionalities are provided by the ```microfilm.microplot``` and ```microfilm.microanim``` modules.

  Following the model of [seaborn](https://seaborn.pydata.org/index.html), ```microfilm``` is entirely based on [Matplotlib](https://matplotlib.org/) and tries to provide good defaults to produce good microcopy figures *out-of-the-box*. It however also offers complete access to the Matplotlib structures like axis and figures underlying the ```microfilm``` objects, allowing thus for the creation of arbitrarily complex plots.



  You can install this package directly with pip using:

  ```
  pip install microfilm
  ```

  To get the latest stage of the package with yet unreleased features use:

  ```
  pip install git+https://github.com/guiwitz/microfilm.git
  ```

  To test the package via the Jupyter interface and the notebooks available [here](notebooks) you can create a conda environment using the [environment.yml](binder/environment.yml) file:

  ```
  conda env create -f environment.yml
  ```



  If you want to use the ```dataset``` submodule (see below in Additional functionalities) and need to handle multipage tiff files or nd2 files, use:

  ```
  pip install "microfilm[multipage]"
  ```

  or

  ```
  pip install "microfilm[nd2]"
  ```

  If you plan to not just use simple plotting but want to create animations, you need to install:

  ```
  pip install "microfilm[animation]"
  ```

  To install all options use:

  ```
  pip install "microfilm[all]"
  ```



  It is straightforward to create a ready-to-use plot of a multi-channel image dataset. In the following code snippet, we load a Numpy array of a multi-channel time-lapse dataset with shape ```CTXY``` (three channels). The figure below showing the time-point ```t=10``` is generated in a single command with a few options and saved as a png:

  ```python
  import numpy as np
  import skimage.io
  from microfilm.microplot import microshow

  image = skimage.io.imread('../demodata/coli_nucl_ori_ter.tif')
  time = 10

  microim = microshow(
      images=image[:, time, :, :], fig_scaling=5,
      cmaps=['pure_blue','pure_red', 'pure_green'],
      unit='um', scalebar_size_in_units=3, scalebar_unit_per_pix=0.065, scalebar_font_size=20,
      label_text='A', label_font_size=0.04)

  microim.savefig('../illustrations/composite.png', bbox_inches = 'tight', pad_inches = 0, dpi=600)
  ```

  <img src="https://github.com/guiwitz/microfilm/raw/master/illustrations/composite.png" alt="image" width="300">



  It is then easy to extend a simple figure into an animation as both objects take the same options. Additionally, a time-stamp can be added to the animation. This code generates the movie visible below:

  ```python
  import numpy as np
  import skimage.io
  from microfilm.microanim import Microanim

  image = skimage.io.imread('../demodata/coli_nucl_ori_ter.tif')

  microanim = Microanim(data=image, cmaps=['pure_blue','pure_red', 'pure_green'], fig_scaling=5,
                        unit='um', scalebar_size_in_units=3, scalebar_unit_per_pix=0.065,
                        scalebar_thickness=0.02, scalebar_font_size=20)

  microanim.add_label('A', label_font_size=30)
  microanim.add_time_stamp('T', 10, location='lower left', timestamp_size=20)

  microanim.save_movie('../illustrations/composite_movie.gif', fps=15)
  ```

  <img src="https://github.com/guiwitz/microfilm/raw/master/illustrations/composite_movie.gif" alt="image" width="300">



  Both simple figures and animations can be combined into larger panels via the ```microplot.Micropanel``` and ```microanim.Microanimpanel``` objects. For example we can first create two figures ```microim1``` and ```microim2``` and then combine them into ```micropanel```:

  ```python
  from microfilm import microplot
  import skimage.io

  image = skimage.io.imread('../demodata/coli_nucl_ori_ter.tif')

  microim1 = microplot.microshow(images=[image[0, 10, :, :], image[1, 10, :, :]],
                                 cmaps=['Greys', 'pure_magenta'], flip_map=[False, False],
                                 label_text='A', label_color='black')
  microim2 = microplot.microshow(images=[image[0, 10, :, :], image[2, 10, :, :]],
                                 cmaps=['Greys', 'pure_cyan'], flip_map=[False, False],
                                 label_text='B', label_color='black')

  micropanel = microplot.Micropanel(rows=1, cols=2, figsize=[4,3])

  micropanel.add_element(pos=[0,0], microim=microim1)
  micropanel.add_element(pos=[0,1], microim=microim2)

  micropanel.savefig('../illustrations/panel.png', bbox_inches = 'tight', pad_inches = 0, dpi=600)
  ```

  <img src="https://github.com/guiwitz/microfilm/raw/master/illustrations/panel.png" alt="image" width="300">

  And similarly for animations:

  ```python
  from microfilm import microanim
  import skimage.io

  image = skimage.io.imread('../demodata/coli_nucl_ori_ter.tif')

  microanim1 = microanim.Microanim(data=image[[0,1],::], cmaps=['Greys', 'pure_magenta'],
                                   flip_map=[False, False], label_text='A', label_color='black')
  microanim2 = microanim.Microanim(data=image[[0,2],::], cmaps=['Greys', 'pure_cyan'],
                                   flip_map=[False, False], label_text='B', label_color='black')

  microanim1.add_time_stamp(unit='T', unit_per_frame='3', location='lower-right', timestamp_color='black')

  animpanel = microanim.Microanimpanel(rows=1, cols=2, figsize=[4,3])
  animpanel.add_element(pos=[0,0], microanim=microanim1)
  animpanel.add_element(pos=[0,1], microanim=microanim2)

  animpanel.save_movie('../illustrations/panel.gif')
  ```

  <img src="https://github.com/guiwitz/microfilm/raw/master/illustrations/panel.gif" alt="image" width="300">



  In addition to these main plotting capabilities, the packages also offers:
  - ```microfilm.colorify```: a series of utility functions used by the main functions to create the composite color images. It contains functions to create colormaps, to turn 2D arrays into 3D-RGB arrays with appropriate colormaps etc.
  - ```microfilm.dataset```: a module offering a simple common data structure to handle multi-channel time-lapse data from multipage tiffs, series of tiff files, Nikon ND2 files, H5 and Numpy arrays. Requirement to use this module are at the moment very constrained (e.g. dimension order of Numpy arrays, name of H5 content etc.) but might evolve in the future.



  This package has been created by Guillaume Witz, Microscopy Imaging Center and Science IT Support, University of Bern.


pkgId: 282c5d1b428424094c70af7ab49799dc154004ba58368d222cc0d02cfc50fd04
name: python-micropolarray-help
arch: noarch
version: 1.2.15
epoch: 0
release: 1
summary: Development documents and examples for micropolarray
url: https://github.com/Hevil33/micropolarray_master
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-micropolarray-1.2.15-1.src.rpm
location_href: Packages/python-micropolarray-help-1.2.15-1.noarch.rpm
checksum_type: sha256
description:
  Python open-source module for loading and using micropolarizer array and PolarCam images.




  Run one of the following commands in your terminal:

  ```
  pip install micropolarray
  ```

  OR

  ```
  pip install git+https://github.com/Hevil33/micropolarray_master
  ```

  If an error message about wheels appear, launch it again.
  You can run the `test.py` script to verify the correct installation of the micopolarray package.



  - Automatic polarization calculation
  - Fast and optimized operations on the micropolarizer array
  - Basic image cleaning (dark/flat subtraction)




  Documentation is hosted at ReadTheDocs and can be found [HERE](https://micropolarray.readthedocs.io/en/latest/) (html format).




  Get the simple [jupyter tutorial](https://github.com/Hevil33/micropolarray_master/blob/main/TUTORIAL.ipynb) for a brief introduction.

  After installation, you can import the library in your python application

  ```
  import micropolarray as ml
  ```

  The main class is `MicropolImage()`, which can be initialized from

  1. A `numpy` 2D array
  2. A list of .fits filenames
  3. Another `MicropolImage()`


  Some useful member functions are :

  MicropolImage()
  - .show()
  - .show_with_pol_params()
  - .rebin()
  - .demosaic()

  Information on polarization is automatically calculated and stored in the class members as `numpy` arrays

  MicropolImage()
  - .data
  - single_pol_subimages
  - .Stokes_vec
  - .I.data
  - .Q.data
  - .U.data
  - pB.data (polarized brightness)
  - AoLP.data (angle of linear polarization)
  - DoLP.data (degree of linear polarization)




  micropolarray:

  - .processing
    - .congrid (_experimental_) : fast congrid operations
    - .convert : raw (binary) files to fits conversion
    - .new_demodulation : image demodulation and demodulation tensor calculation
    - .demosaic : fast image demosaicing
    - .nrgf : occulter finding and roi selection, nrgf filter
    - .rebin : fast image binning
    - .shift : image shifting
  - .cameras (_experimental_) : classes for sensor informations
  - .image : general image handling
  - .utils

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Hevil33  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: 1618e0a84a67174ee8a8ef738b52ca424465cd36820a66a1715edca209db4b71
name: python-micropython-mdns
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: MDNS for micropython with service discovery support
url: https://github.com/cbrand/micropython-mdns
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-micropython-mdns-1.5.1-1.src.rpm
location_href: Packages/python-micropython-mdns-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/micropython-mdns) ![MIT licensed](https://img.shields.io/pypi/l/micropython-mdns)](https://pypi.org/project/micropython-mdns/)

  ![Image showing service discovery](https://raw.githubusercontent.com/cbrand/micropython-mdns/main/images/service-discovery.gif)

  A pure Python implementation of [MDNS](https://tools.ietf.org/html/rfc6762) and the [Service Discovery](https://tools.ietf.org/html/rfc6763) protocol over MDNS
  for [MicroPython](https://micropython.org/).



  You should not use this library if you "just" require MDNS A record lookup and Host annoucement if there is already baked in support in your MicroPython distribution.
  This is for example the case with the default ESP32 MicroPython distribution since v1.12. This will be in all cases more resource efficient.

  If you, however, require additional functionality like Service Discovery and Annoucement, you should use this library. It supports all functionality of existing
  basic MDNS implementations plus these features. You will not loose any functionality.



  The library is available on PyPi and can be installed via upip.

  ```python
  import upip
  upip.install("micropython-mdns")
  ```

  Alternatively you can also use the new [`mip`](https://docs.micropython.org/en/latest/reference/packages.html#installing-packages-with-mip) package manager:

  ```python
  import mip
  mip.install("github:cbrand/micropython-mdns")
  ```

  For using this library, native C type implementations of MDNS which use the MDNS service port need to be disabled. For example, this project has been developed
  on the ESP32 which MicroPython implementation per default has a basic MDNS implementation available. This does only support local A record lookups and A record
  responding of its own host address.

  The [releases page](https://github.com/cbrand/micropython-mdns/releases) on this project publishes a firmware.mp.1.23.esp32.bin for MicroPython 1.23 with MDNS disabled and the mdns python module included in each release for easy usage. Other Micropython versions are also supported. Other boards are supported and you are welcome to add additional Dockerfiles in a PR which build the module compatible for other boards.
  All versions can also be built when having docker locally installed by running in the console the build command:

  ```bash
  make build
  ```

  Individually it is also possible to build the desired version via:

  ```bash
  make compile-micropython-1-15
  make compile-micropython-1-16
  make compile-micropython-1-17
  make compile-micropython-1-18
  make compile-micropython-1-19
  make compile-micropython-1-20
  make compile-micropython-1-21
  make compile-micropython-1-22
  make compile-micropython-1-23
  make compile-micropython-1-24
  ```

  Refer to the [`config`](https://github.com/cbrand/micropython-mdns/tree/main/config/boards) directory to see the configuration files when baking this into your own MicroPython ESP32 build.

  For Raspberry Pi Pico support see the corresponding Dockerfile on how to compile it in linux [`Dockerfile.micropython.1.23.rp2`](https://github.com/cbrand/micropython-mdns/tree/main/Dockerfile.micropython.1.23.rp2).

  Other MicroPython implementations might not require any changes inside of the firmware.



  The library requires [`uasyncio`](https://docs.micropython.org/en/latest/library/uasyncio.html) to function. All handling is done asynchronously.

  Examples on how to utilize the libraries can be found in the [`examples`](https://github.com/cbrand/micropython-mdns/tree/main/examples) folder.



  A basic API reference for the public API is inside of the [REFERENCE.md](https://github.com/cbrand/micropython-mdns/blob/main/REFERENCE.md).



  - Depending on your MicroPython implementation, you must disable MDNS in the firmware.
    - For ESP32 use the Dockerfile for the specific Micropython version in the root directory.
    - For RPI Pico Micropython beginning with version 1.32 is supported since version 1.5.0 where you can see how to do it in the Dockerfile in the root directory.
  - Currently no support for IPv6 is implemented.
  - Depending how chatty the network is, service responders and discovery might require a lot of memory. If the memory is filled by the buffer of the underlying socket, [the socket is closed and reopened](https://github.com/cbrand/micropython-mdns/blob/d3dd54f809629ca41c525f5dec86963a6d75e903/src/mdns_client/client.py#L100) which looses data. It, however, seems to work fine enough in tests on an ESP32 without external memory. Depending on the project size, a module with external RAM might be advisable.



  The library is published under the [MIT](https://github.com/cbrand/micropython-mdns/blob/main/LICENSE) license.


pkgId: b46a9f04eb28fe5d740aa5693c81ecd224d33082eff0a9aad1dab13cb7196c58
name: python-microschc
arch: noarch
version: 0.18.1
epoch: 0
release: 1
summary: Implementation in microPython of SCHC as specified in RFC 8724
url: https://github.com/quentinlampin/microschc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-microschc-0.18.1-1.src.rpm
location_href: Packages/python-microschc-0.18.1-1.noarch.rpm
checksum_type: sha256
description:
  Implementation in microPython of SCHC as specified in RFC 8724 [1].



  MIT License, Copyright (c) 2022 Orange, by Quentin Lampin



  Releases of microSCHC are available on PyPI. To install microSCHC, run

  ```bash
  pip install microschc
  ```

  Latest (pre-release) microSCHC versions can be built from source using `hatch` and installed using the wheel (.whl) file generated in the `dist/` folder.

  **build**:

  ```bash
  hatch build -t wheel
  ```

  **installation**:

  ```bash
  pip install dist/microschc-<version>-py3-none-any.whl
  ```



  microSCHC aims at implementing the SCHC Compression/Decompression (C/D) and Fragmentation/Reassembly (F/R) routines described in RFC 8724 [1].

  The initial focus of this effort is on the Compression/Decompression (C/D) routines and parsers for typical IoT protocol stacks, i.e. based
  on IPv6 [2], UDP [3], CoAP [4], lwM2M.

  Current features:

  1. Parsers
     - [x] IPv4
     - [x] IPv6
     - [x] UDP
     - [x] CoAP (partial test coverage: options missing)
     - [x] CoAP over UDP over IPv6 stack parser
     - [ ] lwM2M ( when not using CoAP options, i.e. CoAP payloads) --> postponed to after full SCHC C/D implementation
  2. Matching Operators (MO)
     - [x] equal
     - [x] ignore
     - [x] MSB(x)
     - [x] match-mapping
  3. Compression/Decompression Actions (CDA)
     1. Compression
        - [x] not-sent
        - [x] value-sent
        - [x] mapping-sent
        - [x] LSB
        - [x] compute-* (e.g. UDP-checksum)
        - [ ] devIID
        - [ ] AppIID

     2. Decompression counterparts
        - [x] not-sent
        - [x] value-sent
        - [x] mapping-sent
        - [x] LSB
        - [-] compute-* (e.g. UDP-checksum)
           - [x] UDP Checksum
           - [x] UDP Length
           - [x] IPv6 Payload Length
           - [ ] IPv4 Payload Length
        - [ ] devIID
        - [ ] AppIID

  4. Rules
     - [x] rule data model
     - [x] rule matching algorithm
     - [ ] YANG model interpreter
  5. Compression
     - [x] field (left-)packet
     - [x] field residues concatenation
     - [x] length of variable length field encoding
     - [x] packet compression
  6. Context Management
     - [x] Definition & implementation of custom SCHC Context (not specified in RFCs)

  - [1] "RFC 8724 SCHC: Generic Framework for Static Context Header Compression and Fragmentation" , A. Minaburo et al.
  - [2] "RFC 8200 Internet Protocol, Version 6 (IPv6) Specification, S. Deering et al."
  - [3] "RFC 768 User Datagram Protocol, J. Postel"
  - [4] "RFC 7252 The Constrained Application Protocol (CoAP), Z. Shelby et al."


pkgId: 2ab0d58ff961fc64623d77137ca75369e267a3a2a17251097ba8f30dd661fc33
name: python-microsoft-kiota-abstractions-help
arch: noarch
version: 1.6.7
epoch: 0
release: 1
summary: Development documents and examples for microsoft-kiota-abstractions
url: https://github.com/microsoft/kiota#readme
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-microsoft-kiota-abstractions-1.6.7-1.src.rpm
location_href: Packages/python-microsoft-kiota-abstractions-help-1.6.7-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/microsoft-kiota-abstractions.svg)](https://badge.fury.io/py/microsoft-kiota-abstractions)
  [![Downloads](https://pepy.tech/badge/microsoft-kiota-abstractions)](https://pepy.tech/project/microsoft-kiota-abstractions)

  The Microsoft Kiota abstractions library for Python is the python package defining the basic constructs Kiota projects need once an SDK has been generated from an OpenAPI definition.

  A [Kiota](https://github.com/microsoft/kiota) generated project will need a reference to the abstraction package to build and run.

  Read more about Kiota [here](https://github.com/microsoft/kiota/blob/main/README.md).



  In order to use this library, install the package by running:

  ```cmd
  pip install microsoft-kiota-abstractions
  ```



  This project welcomes contributions and suggestions.  Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit <https://cla.opensource.microsoft.com>.

  When you submit a pull request, a CLA bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.



  This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
  trademarks or logos is subject to and must follow
  [Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
  Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
  Any use of third-party trademarks or logos are subject to those third-party's policies.


pkgId: f8477c5b17a96affbd7c2d37c4be3284bbdecb80fc0725827efe8b280e9d942b
name: python-microwink-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for microwink
url: https://pypi.org/project/microwink/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-microwink-0.0.1-1.src.rpm
location_href: Packages/python-microwink-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Lightweight instance segmentation model for card IDs



  ```python
  from microwink import SegModel
  from microwink.common import draw_mask
  from PIL import Image

  seg_model = SegModel.from_path("./models/seg_model.onnx")

  img = Image.open("...").convert("RGB")
  cards = seg_model.apply(img)

  for card in cards:
      print(f"{card.score=}, {card.box=}")
      img = draw_mask(img, card.mask > 0.5)
  img.save("result.png")
  ```


pkgId: 70aa78c55825b2eccfc02f648c41e317a7b103ff1210e3bb63d305d614ef9fcf
name: python-midas-mosaik-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for midas-mosaik
url: https://gitlab.com/midas-mosaik/midas
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-midas-mosaik-1.2.2-1.src.rpm
location_href: Packages/python-midas-mosaik-help-1.2.2-1.noarch.rpm
checksum_type: sha256
description:
  The MultI-DomAin test Scenario (MIDAS) is a collection of mosaik simulators (https://gitlab.com/mosaik) for smart grid co-simulation and contains a semi-automatic scenario configuration tool.
  The latest documentation is always available at https://midas-mosaik.gitlab.io/midas.

  Version: 1.2



  All required Python packages will be pulled during installation.
  However, there are some additional requirements which you have to setup up manually.

  First of all, you need a working Python installation >= 3.8.
  Download it from (https://www.python.org/) or use your systems' package manager.
  Furthermore, you will need to have a working Git installation, which you can
  find on https://git-scm.com/downloads (or via your package manager).

  Midas is able to create an analysis report of the simulation results.
  If you have a working pandoc (https://pandoc.org/) installation, this report will automatically be converted to an .odt file.
  This is **purely optional**.



  MIDAS is available on https://pypi.org and can be installed, preferably into a virtualenv, with

  ```bash
  pip install midas-mosaik
  ```

  Alternatively, to install directly from the source, you can clone this repository with

  ```bash
  git clone https://gitlab.com/midas-mosaik/midas.git
  ```

  then switch to the midas folder and type

  ```bash
  pip install .
  ```

  for a normal install and

  ```bash
  pip install -e .
  ```

  for an *editable* install, i.e., changes you make in the source do not require a reinstall.

  See the documation at https://midas-mosaik.gitlab.io/midas/installation.html for OS-specific installation instructions.



  MIDAS comes with a command line tool called `midasctl` that let's you conveniently start your scenario and/or add minor modifications to it (e.g. change the number of simulations steps, write to a different database, etc.).
  `midasctl` also helps doing the initial setup of MIDAS.
  Just type

  ```bash
  midasctl configure
  ```

  and you will be asked to specify where the runtime configuration of MIDAS should be stored and where you want the datasets to be located. You can of course let MIDAS decide this for you, just append `-a` to the command:

  ```bash
  midasctl configure -a
  ```

  Afterwards, you need to download the datasets that MIDAS will use. Type

  ```bash
  midasctl download
  ```
  and wait a moment until MIDAS is done. Finally, you can test your installation with

  ```bash
  midasctl run demo
  ```

  This will run a demonstration scenario and should not take very long.

  Pro tip: If you just run the last command, configuration and download will be performed implicitly.




  The datasets are pulled from different locations.

  The default load profiles are publicly available at https://www.bdew.de/energie/standardlastprofile-strom/

  The commercial data set is retrieved from https://data.openei.org/submissions/153 and is released under the Creative Commons License: https://creativecommons.org/licenses/by/4.0/
  The energy values are converted from Kilowatt to Megawatt and are slightly rearranged to be usable with MIDAS.

  The simbench datasets are directly extracted from the simbench pypi package.

  The smart nord dataset comes from the research project Smart Nord (www.smartnord.de).

  The Weather datasets are publicly available at https://opendata.dwd.de/ (see the Copyright information: https://www.dwd.de/EN/service/copyright/copyright_node.html)
  Since sometimes values are missing, those values are filled with previous orsimilar values.




  There is a Docker file that can be used to run the MIDAS command line tool.
  And there is an install script for those working on LINUX, simply run:

  ```bash
  ./build_docker.sh
  ```

  Afterwards, execute

  ```bash
  docker run \
      -v PATH_TO_MIDAS_DATA:/home/user/.config/midas/midas_data \
      -v PATH_TO_OUTPUT_DIR:/app/_outputs \
      midas run midasmv
  ```

  to run the *midasmv* scenario in the docker.
  Replace `PATH_TO_MIDAS_DATA` with the absolute path to your MIDAS data directory (usually located at ~/.config/midas/midas_data).
  Replace `PATH_TO_OUTPUT_DIR` with the location where the outputs should be stored.

  If you create a runtime config in the same directory as the Dockerfile before run the build command, this file will be included.
  However, you should not change the output_path and the data_path, otherwise you will have to adapt the run command as well.



  If you want to use Midas in your research, you can cite this publication:

  ```
  @InProceedings{10.1007/978-3-031-43824-0_10,
      author="Balduin, Stephan
      and Veith, Eric M. S. P.
      and Lehnhoff, Sebastian",
      editor="Wagner, Gerd
      and Werner, Frank
      and De Rango, Floriano",
      title="Midas: An Open-Source Framework for Simulation-Based Analysis of Energy Systems",
      booktitle="Simulation and Modeling Methodologies, Technologies and Applications",
      year="2023",
      publisher="Springer International Publishing",
      address="Cham",
      pages="177--194",
      isbn="978-3-031-43824-0"
  }


  ```


pkgId: 38a4fabf66fab8cafca2f94e0e587cb72ac4ed1e0947c0636ea7fad033e4c85e
name: python-midas-powergrid-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for midas-powergrid
url: https://gitlab.com/midas-mosaik/midas-powergrid
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-midas-powergrid-1.2.1-1.src.rpm
location_href: Packages/python-midas-powergrid-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains a MIDAS module providing a pandapower simulator and a number of custom powergrids.

  Although this package is intended to be used with MIDAS, it does not depend from anything MIDAS-related except for the `midas-util` package. You can use in any mosaik simulation scenario.


  This package will usually installed automatically together with `midas-mosaik`. It is available on pypi, so you can install it manually with

  ```bash
  pip install midas-powergrid
  ```


  The complete documentation is available at https://midas-mosaik.gitlab.io/midas.


  To use the powergrid inside of MIDAS, just add `powergrid` to your modules

  ```yaml
  my_scenario:
    modules:
      - powergrid
      - ...
  ```

  and configure it with (`gridfile` is required, everything else is optional and can be left out if the default values, shown below, are used):


  ```yaml
    powergrid_params:
      my_grid_scope:
        gridfile: midasmv
        grid_params: {}
        step_size: 900
        plotting: False
        plot_path: _plots # Output path defined in runtime config
        save_grid_json: False
  ```

  All simulators that want to connect to this grid, will have to use `my_grid_scope` as their `grid_name` value. Activating the plotting will results in a considerably longer execution time. Activate it only if you really need this feature.

  The gridfile can be either a path to a .json or .xlsx file, a simbench grid code, one of `cigre_hv`, `cigre_mv`, `cigre_lv`, `midasmv`, `midaslv`, or `bhv`, or an import path to a function or class that either returns a valid pandapower grid or is a pandapower grid itself. The `grid_params` can be used to pass keywork arguments to custom grids.


  If you don't use MIDAS, you can add the `powergrid` manually to your mosaik scenario file. First, the entry in the `sim_config`:

  ```python
  sim_config = {
      "Powergrid": {"python": "midas.modules.powergrid:PandapowerSimulator"},
      
  }
  ```

  Next, you need to start the simulator (assuming a `step_size` of 900):

  ```python
  powergrid_sim = world.start("Powergrid", step_size=900, plotting=False, plot_path="path/to/store/plots")
  ```

  Finally, the model needs to be started:

  ```python
  powergrid = powergrid_sim.Grid(gridfile="midasmv", grid_params={})
  ```

  To connect the output of the grids' buses to another model, you have to get the list of bus models from the powergrids' children like

  ```python
  bus_models = [e for e in powergrid.children if "bus" in e.eid]
  ```

  and then connect those models either individually or in a loop, e.g.,

  ```python
  for bus in bus_models:
      world.connect(bus, other_entity, "vm_pu", "va_degree", "p_mw", "q_mvar")
  ```

  The inputs are generally handled in the same way. Have a look at `powergrid.children` to get the required entity eids.


  This software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.


pkgId: d3b301fc228fb1d576a7eeba84af62a9e3145e834a7546e0512a2997a52b0c51
name: python-midas-powerseries-help
arch: noarch
version: 2.0.0rc1
epoch: 0
release: 1
summary: Development documents and examples for midas-powerseries
url: https://pypi.org/project/midas-powerseries/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-midas-powerseries-2.0.0rc1-1.src.rpm
location_href: Packages/python-midas-powerseries-help-2.0.0rc1-1.noarch.rpm
checksum_type: sha256
description:
  The midas power series module is a general purpose data simulator, currently focussed on csv files.

  Although this package is intended to be used with midas, it can be used in any mosaik simulation scenario.



  This package will usually be installed automatically by most of the other data simulators from midas.
  It is available on pypi, so you can install it manually with

  ```bash
  pip install midas-powerseries
  ```



  The complete documentation is available at https://midas-mosaik.gitlab.io/midas.



  There are already a few data simulators for specific data sets that can be used instead of this simulator.
  However, if you have a csv file with time series and want to use it in a midas scenario, you have to add `powerseries` to your modules

  ```yaml
  my_scenario:
    modules:
      - powerseries
      - ...
  ```

  The configuration needs to provide the path to your csv file and how the data should be connected to the power grid.

  ```yaml
    powerseries_params:
      my_grid_scope:
        step_size: 900  # <-- Default value
        data_path: "path/to/folder/containing/csv/file"
        filename: "my_time_series.csv"
        data_step_size: 900  # <-- Default value
        data_scaling: 1.0  # Default value; use it if your data is, e.g., in kW instead of MW
        meta_scaling: 1.0  # Default value; use it to scale all of the time series globally
        active_mapping:
          0: [[load_01_p_mw, 1.0], [load_02_p_mw], 1.2]  # load_01_p_mw and load_02_p_mw have to be column names in the csv file
  ```



  tbd



  This software is released under the GNU Lesser General Public License (LGPL).
  See the license file for more information about the details.


pkgId: 1173371bd627c588deac9477b94c80791956ef22784a80045375b6797836d1d9
name: python-midas-timesim-help
arch: noarch
version: 2.0.0rc1
epoch: 0
release: 1
summary: Development documents and examples for midas-timesim
url: https://pypi.org/project/midas-timesim/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-midas-timesim-2.0.0rc1-1.src.rpm
location_href: Packages/python-midas-timesim-help-2.0.0rc1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains a midas *timesim* module, which contains a simulator that tracks time and is able to manipulate it within the simulation.

  The intended use-case for the time simulator is to be used inside of midas.
  However, it can be used in any mosaik simulation scenario.



  This package will installed automatically together with `midas-mosaik` if you opt-in for the `full` extra.
  It is available on pypi, so you can install it manually with

  ```bash
  pip install midas-timesim
  ```



  The complete documentation is available at https://midas-mosaik.gitlab.io/midas.



  To use the time simulator inside of midas, simply add `timesim` to your modules:

  ```yaml
      my_scenario:
        modules:
          - timesim
          
  ```

  This is sufficient for the timesim to run.
  However, additional configuration is possible with:

  ```yaml
      my_scenario:
        
        timesim_params:
          start_date: 2020-01-01 01:00:00+0100
  ```

  All of the core simulators that have support time inputs will then automatically connect to the *timesim* simulator.
  The scope *timesim* will be created automatically but no other scopes are supported.



  If you don't use midas, you can add the `timesim` manually to your mosaik scenario file.
  First, the entry in the `sim_config`:

  ```python
      sim_config = {
          "TimeSimulator": {"python": "midas_timesim.simulator:TimeSimulator"},
          
      }
  ```

  Next, you need to start the simulator (assuming a `step_size` of 900):

  ```python
      timesim_sim = world.start("TimeSimulator", step_size=900)
  ```

  Finally, the model needs to be started:

  ```python
      timesim = timesim_sim.Timegenerator()
  ```

  Afterwards, you can define `world.connect(timesim, other_entity, attrs)` as you like.



  This software is released under the GNU Lesser General Public License (LGPL).
  See the license file for more information about the details.


pkgId: 0732fabe5848e2bf16b66b4c007745ffd48374af56da47b0285b21cb5c84f1be
name: python-middleware-io-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for middleware-io
url: https://docs.middleware.io/docs/apm-configuration/python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-middleware-io-2.0.0-1.src.rpm
location_href: Packages/python-middleware-io-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![LinkedIn][linkedin-shield]][linkedin-url]

  <br />
  <div align="center">

    <h1 align="center">Middleware - Python APM</h1>

    <p align="center">
      An Application Performance Monitoring (APM) tool for Python applications and libraries
      <br />
      <a href="https://docs.middleware.io/apm-configuration/python"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <a href="https://github.com/middleware-labs/agent-apm-python/issues/new?labels=bug&template=bug-report---.md">Report Bug</a>
      ·
      <a href="https://github.com/middleware-labs/agent-apm-python/issues/new?labels=enhancement&template=feature-request---.md">Request Feature</a>
    </p>
  </div>



  [![Product Name Screen Shot][product-screenshot]](https://middleware.io/)

  Middleware's APM (Application Performance Monitoring) tool offers a comprehensive solution for developers seeking to enhance the performance and observability of their Python applications.

  By installing the Middleware Host Agent and integrating the APM package, developers can seamlessly monitor applications, capturing distributed tracing data, metrics, logs, and profiling information. This enables a thorough view of application performance and behavior.

  For detailed instructions on installing the Middleware Host Agent and integrating the APM package, refer to our [documentation](https://docs.middleware.io/apm-configuration/python) for Python applications.

  Latest release built with:

  - [OpenTelemetry version 1.27.0/0.48b0](https://github.com/open-telemetry/opentelemetry-python/releases/tag/v1.27.0)

  Requirements

  - Python 3.8 or higher



  Run the following command in your terminal:

  ```shell
  pip install middleware-io
  ```

  To install with **Continuous Profiling** support:

  ```shell
  pip install middleware-io[profiling]
  ```

  For further details on prerequisites, configuration options, and use, visit our docs page at [https://docs.middleware.io/apm-configuration/python](https://docs.middleware.io/apm-configuration/python).

  For framwork based python instrumentation examples, visit github repo at  [https://github.com/middleware-labs/demo-apm-python](https://github.com/middleware-labs/demo-apm-python).

  <!-- LICENSE -->


  Distributed under the Apache License. See `LICENSE` for more information.

  [contributors-shield]: https://img.shields.io/github/contributors/middleware-labs/agent-apm-python.svg?style=for-the-badge
  [contributors-url]: https://github.com/middleware-labs/agent-apm-python/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/middleware-labs/agent-apm-python.svg?style=for-the-badge
  [forks-url]: https://github.com/middleware-labs/agent-apm-python/network/members
  [stars-shield]: https://img.shields.io/github/stars/middleware-labs/agent-apm-python.svg?style=for-the-badge
  [stars-url]: https://github.com/middleware-labs/agent-apm-python/stargazers
  [issues-shield]: https://img.shields.io/github/issues/middleware-labs/agent-apm-python.svg?style=for-the-badge
  [issues-url]: https://github.com/middleware-labs/agent-apm-python/issues
  [license-shield]: https://img.shields.io/github/license/middleware-labs/agent-apm-python.svg?style=for-the-badge
  [license-url]: https://github.com/middleware-labs/agent-apm-python/blob/master/LICENSE
  [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://www.linkedin.com/company/middleware-labs
  [product-screenshot]: ./product.png


pkgId: a610270744a753cc3a7dfbb6f15f9e2cfd90ca05bbeb9f23923e9d4ee63b9e26
name: python-midsv-help
arch: noarch
version: 0.11.1
epoch: 0
release: 1
summary: Development documents and examples for midsv
url: https://github.com/akikuno/midsv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-midsv-0.11.1-1.src.rpm
location_href: Packages/python-midsv-help-0.11.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Licence](https://img.shields.io/badge/License-MIT-9cf.svg?style=flat-square)](https://choosealicense.com/licenses/mit/)
  [![Test](https://img.shields.io/github/actions/workflow/status/akikuno/midsv/ci.yml?branch=main&label=Test&color=brightgreen&style=flat-square)](https://github.com/akikuno/midsv/actions)
  [![Python](https://img.shields.io/pypi/pyversions/midsv.svg?label=Python&color=blue&style=flat-square)](https://pypi.org/project/midsv/)
  [![PyPI](https://img.shields.io/pypi/v/midsv.svg?label=PyPI&color=orange&style=flat-square)](https://pypi.org/project/midsv/)
  [![Bioconda](https://img.shields.io/conda/v/bioconda/midsv?label=Bioconda&color=orange&style=flat-square)](https://anaconda.org/bioconda/midsv)




  `midsv` is a Python module to convert SAM to MIDSV format.

  MIDSV (Match, Insertion, Deletion, Substitution, and inVersion) is a comma-separated format representing the difference between a reference and a query with the same length as the reference.

  > ⚠️ MIDSV is for the target amplicon sequence (10-100 kbp). It may crash when whole chromosomes are used as reference due to running out of memory.

  MIDSV provides `MIDSV`, `CSSPLIT`, and `QSCORE`.

  - `MIDSV` is a simple representation focusing on mutations
  - `CSSPLIT` keeps original nucleotides
  - `QSCORE` provides Phred quality score on each nucleotide

  MIDSV (formerly named MIDS) details are described in [our paper](https://journals.plos.org/plosbiology/article?id=10.1371/journal.pbio.3001507#sec009).



  From [PyPI](https://pypi.org/project/midsv/):

  ```bash
  pip install midsv
  ```

  From [Bioconda](https://anaconda.org/bioconda/midsv):

  ```bash
  conda install -c bioconda midsv
  ```



  ```python
  midsv.transform(
      sam: list[list],
      midsv: bool = True,
      cssplit: bool = True,
      qscore: bool = True) -> list[dict]
  ```

  - `midsv.transform()` returns a list of dictionaries incuding `QNAME`, `RNAME`, `MIDSV`, `CSSPLIT`, and `QSCORE`.
  - `MIDSV`, `CSSPLIT`, and `QSCORE` are comma-separated and have the same reference sequence length.

  ```python
  import midsv



  sam = [
      ['@SQ', 'SN:example', 'LN:10'],
      ['match', '0', 'example', '1', '60', '10M', '*', '0', '0', 'ACGTACGTAC', '0123456789', 'cs:Z:=ACGTACGTAC']
      ]

  midsv.transform(sam)










  sam = [
      ['@SQ', 'SN:example', 'LN:10'],
      ['indel_sub', '0', 'example', '1', '60', '5M3I1M2D2M', '*', '0', '0', 'ACGTGTTTCGT', '01234!!!56789', 'cs:Z:=ACGT*ag+ttt=C-aa=GT']
      ]

  midsv.transform(sam)










  sam = [
      ['@SQ', 'SN:example', 'LN:10'],
      ['large-deletion', '0', 'example', '1', '60', '2M', '*', '0', '0', 'AC', '01', 'cs:Z:=AC'],
      ['large-deletion', '0', 'example', '9', '60', '2M', '*', '0', '0', 'AC', '89', 'cs:Z:=AC']
      ]

  midsv.transform(sam)










  sam = [
      ['@SQ', 'SN:example', 'LN:10'],
      ['inversion', '0', 'example', '1', '60', '5M', '*', '0', '0', 'ACGTA', '01234', 'cs:Z:=ACGTA'],
      ['inversion', '16', 'example', '6', '60', '3M', '*', '0', '0', 'CGT', '567', 'cs:Z:=CGT'],
      ['inversion', '2048', 'example', '9', '60', '2M', '*', '0', '0', 'AC', '89', 'cs:Z:=AC']
      ]

  midsv.transform(sam)








  ```





  | Op          | Description                 |
  | ----------- | --------------------------- |
  | M           | Identical sequence          |
  | [1-9][0-9]+ | Insertion to the reference  |
  | D           | Deletion from the reference |
  | S           | Substitution                |
  | N           | Unknown                     |
  | [mdsn]      | Inversion                   |

  `MIDSV` represents insertion as an integer and appends the following operators.

  If five insertions follow three matches, MIDSV returns `5M,M,M` (not `5,M,M,M`) since `5M,M,M` keeps reference sequence length in a comma-separated field.



  | Op  | Regex          | Description                  |
  | --- | -------------- | ---------------------------- |
  | =   | [ACGTN]        | Identical sequence           |
  | +   | [ACGTN]        | Insertion to the reference   |
  | -   | [ACGTN]        | Deletion from the reference  |
  | *   | [ACGTN][ACGTN] | Substitution                 |
  |     | [acgtn]        | Inversion                    |
  | \|  |                | Separater of insertion sites |

  `CSSPLIT` uses `|` to separate nucleotides in insertion sites.

  Therefore, `+A|+C|+G|+T|=A` can be easily splited to `[+A, +C, +G, +T, =A]` by `"+A|+C|+G|+T|=A".split("|")` in Python.




  | Op  | Description                  |
  | --- | ---------------------------- |
  | -1  | Unknown                      |
  | \|  | Separator at insertion sites |

  `QSCORE` uses `-1` at deletion or unknown nucleotides.

  As with `CSSPLIT`, `QSCORE` uses `|` to separate quality scores in insertion sites.





  ```python
  midsv.read_sam(path_of_sam: str | Path) -> list[list]
  ```

  `midsv.read_sam` read SAM file into a list of lists.




  ```python
  midsv.write_jsonl(dict: list[dict], path_of_jsonl: str | Path)
  ```

  ```python
  midsv.read_jsonl(path_of_jsonl: str | Path) -> list[dict]
  ```

  Since `midsv` returns a list of dictionaries, `midsv.write_jsonl` outputs it to a file in JSONL format.

  Conversely, `midsv.read_jsonl` reads JSONL as a list of dictionaries.


pkgId: e6458565bb7e444e5e97475e24d35fb7ca199ac9671fee3aec657997c87d4f30
name: python-mijiaAPI-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for mijiaAPI
url: https://github.com/Do1e/mijia-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mijiaAPI-1.2.0-1.src.rpm
location_href: Packages/python-mijiaAPI-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  小米米家设备的api，可以使用代码直接控制米家设备的功能


  ```bash
  python setup.py install
  ```
  或者
  ```bash
  pip install mijiaAPI
  ```


  使用实例可以参考`demos`文件夹下的示例代码，以下是简单的使用说明

  有三个类分别用于登录和API调用

  * `mijiaLogin`：登录小米账号，获取控制设备必须的`userId`, `ssecurity`, `deviceId`, `serviceToken`，方法列表
    * `login(username: str, password: str) -> dict`：账号密码登录，返回上述信息
    * `QRlogin() -> dict`：扫描二维码登录，返回上述信息（会在支持tty的终端打印二维码，若打印识别可查看当前文件夹下的`qr.png`）

  * `mijiaAPI`：API的实现，使用`mijiaLogin`登录后返回的信息进行初始化
    * `__init__(auth_data: dict)`：初始化
    * `available -> bool`：传入的`auth_data`是否有效
    * `get_devices_list() -> list`：获取设备列表
    * `get_homes_list() -> list`：获取家庭列表，家庭字典中包含房间列表
    * `get_scenes_list(home_id: str) -> list`：获取手动场景列表，在 *米家->添加->手动控制* 中设置
    * `run_scene(scene_id: str) -> bool`：运行手动场景
    * `get_consumable_items(home_id: str) -> list`：获取设备的耗材信息
    * `get_devices_prop(data: list) -> list`：获取设备的属性
    * `set_devices_prop(data: list) -> list`：设置设备的属性
      * `data`为一个字典的列表，字典需要包含`did`, `siid`, `piid`，后面两个键可从 *https://home.miot-spec.com/spec/{model}* 中获取，其中`model`为设备的model，在设备列表中获取，如[米家台灯 1S](https://home.miot-spec.com/spec/yeelink.light.lamp4)。
      * 网站上的方法并非全部可用，需要自行测试


  * `mijiaDevices`：使用`mijiaAPI`和设备属性字典初始化，以便更方便地调用设备属性
    * `__init__(api: mijiaAPI, dev_info: dict. did: str = None, sleep_time: float = 0.5)`：初始化，`dev_info`为设备属性，参考[demos/dev_info_example](demos/dev_info_example)，`sleep_time`为每次调用设备属性的间隔时间（注：设置属性后立刻获取属性会不符合预期，需要延迟一段时间）
    * `set(name: str, did: str, value: Union[bool, int]) -> Union[bool, int]`：设置设备属性
    * `get(name: str, did: str) -> Union[bool, int]`：获取设备属性
    * v1.2.0 新增直接通过名称设置/获取属性，需要在初始化时传入`did`，详见[demos/test_devices_v2_light.py](demos/test_devices_v2_light.py)。名称中包含`-`的属性需要替换为`_`。
    * **欢迎大家把自己编写的设备属性字典分享到Issues中，方便大家使用**


  * [janzlan/mijia-api](https://gitee.com/janzlan/mijia-api/tree/master)


  * 本项目仅供学习交流使用，不得用于商业用途，如有侵权请联系删除。
  * 本项目作者不对使用本项目产生的任何后果负责，请用户自行承担使用本项目的风险。


pkgId: 95865cba3b0008101e9401d26800aceaaf7bb0ab9bc25d1086546cbdf0d5f7be
name: python-milliman-sensi-help
arch: noarch
version: 1.1.12
epoch: 0
release: 1
summary: Development documents and examples for milliman-sensi
url: https://dev.azure.com/millimanparis/CHESS-Sensitivity-Manager
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-milliman-sensi-1.1.12-1.src.rpm
location_href: Packages/python-milliman-sensi-help-1.1.12-1.noarch.rpm
checksum_type: sha256
description:
  A parser and modifier of CHESS's configuration
  To parse configuration files and apply them to create new sensitivity tables


pkgId: c6e34df483215fef2773dd43e6c965cee6f32538cd26606089c11ca5141dfdd1
name: python-milvus-cli-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for milvus-cli
url: https://github.com/zilliztech/milvus_cli
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-milvus-cli-1.0.1-1.src.rpm
location_href: Packages/python-milvus-cli-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/zilliztech/milvus_cli?include_prereleases) ![PyPI](https://img.shields.io/pypi/v/milvus-cli)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/milvus_cli?label=PYPI%20downloads) ![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/downloads-pre/zilliztech/milvus_cli/latest/total?label=Release%40latest%20downloads) ![Docker Pulls](https://img.shields.io/docker/pulls/zilliz/milvus_cli)
  ![GitHub repo size](https://img.shields.io/github/repo-size/zilliztech/milvus_cli) ![PyPI - License](https://img.shields.io/pypi/l/milvus-cli)



  [Milvus](https://github.com/milvus-io/milvus) Command Line Interface based on [Milvus Python SDK](https://github.com/milvus-io/pymilvus).

  - Applicable to most platforms: MS Windows, macOS, Ubuntu

  - Support pip install & offline installation package

  - Support single executable file

  - Milvus Python SDK full function coverage

  - Built-in help function

  - Support auto completion







  Python >= 3.8.5



  Run `pip install pymilvus>=2.4.3`
  Run `pip install milvus-cli==1.0.1`



  1. Download the [latest release](https://github.com/zilliztech/milvus_cli/releases/latest) of ` milvus_cli-<version>.tar.gz`.
  2. Run `pip install milvus_cli-<version>.tar.gz`.



  1. Run `git clone https://github.com/zilliztech/milvus_cli.git`.
  2. Run `cd milvus_cli`.
  3. Run `pip install --editable .`





  Download the [latest release](https://github.com/zilliztech/milvus_cli/releases/latest) of `milvus_cli.exe` and run it.



  1. Download the [latest release](https://github.com/zilliztech/milvus_cli/releases/latest) of `milvus_cli-<version>-Linux`.
  2. Run `sudo chmod +x milvus_cli-<version>-Linux` to allow executing `milvus_cli-<version>-Linux` as program.
  3. Run `./milvus_cli-<version>-Linux`.



  1. Download the [latest release](https://github.com/zilliztech/milvus_cli/releases/latest) of `milvus_cli-<version>-macOS`.
  2. Run `sudo chmod +x milvus_cli-<version>-macOS` to allow executing `milvus_cli-<version>-macOS` as program.
  3. Run `./milvus_cli-<version>-macOS`.



  `docker run -it zilliz/milvus_cli:latest`



  Run `milvus_cli` (in a Python environment) or double click `milvus_cli-<version>.exe` file (in a Windows environment).



  - In a Python environment, run `milvus_cli`.
  - In a Windows environment, double click `milvus_cli-<version>.exe`.
  - In an Ubuntu environment, run `./milvus_cli-<version>-Linux`.
  - In a MacOS environment, run `./milvus_cli-<version>-macOS`.



  https://milvus.io/docs/cli_commands.md



  💬 Community isn’t just about writing code together. Come join the conversation, share your knowledge and get your questions answered on [Milvus Slack Channel](https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ)!

  <a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">
      <img src="https://assets.zilliz.com/readme_slack_4a07c4c92f.png" alt="Miluvs Slack Channel"  height="150" width="500">
  </a>

  <br><!-- Do not remove start of hero-bot --><br>
  <img src="https://img.shields.io/badge/all--contributors-6-orange"><br>
  <a href="https://github.com/chris-zilliz"><img src="https://avatars.githubusercontent.com/u/91247127?v=4" width="30px" /></a>
  <a href="https://github.com/czhen-zilliz"><img src="https://avatars.githubusercontent.com/u/83751452?v=4" width="30px" /></a>
  <a href="https://github.com/haorenfsa"><img src="https://avatars.githubusercontent.com/u/15938850?v=4" width="30px" /></a>
  <a href="https://github.com/kateshaowanjou"><img src="https://avatars.githubusercontent.com/u/58837504?v=4" width="30px" /></a>
  <a href="https://github.com/matrixji"><img src="https://avatars.githubusercontent.com/u/183388?v=4" width="30px" /></a>
  <a href="https://github.com/sre-ci-robot"><img src="https://avatars.githubusercontent.com/u/56469371?v=4" width="30px" /></a>
  <br><!-- Do not remove end of hero-bot --><br>


pkgId: e58262be7c9c25e65962296b10df076aa36db44edbb193705bae866bf386c8ad
name: python-milvus-haystack-help
arch: noarch
version: 0.0.13
epoch: 0
release: 1
summary: Development documents and examples for milvus-haystack
url: https://pypi.org/project/milvus-haystack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-milvus-haystack-0.0.13-1.src.rpm
location_href: Packages/python-milvus-haystack-help-0.0.13-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/milvus-haystack.svg)](https://pypi.org/project/milvus-haystack)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/milvus-haystack.svg)](https://pypi.org/project/milvus-haystack)



  ```shell
  pip install --upgrade pymilvus milvus-haystack
  ```



  Use the `MilvusDocumentStore` in a Haystack pipeline as a quick start.

  ```python
  from haystack import Document
  from milvus_haystack import MilvusDocumentStore

  document_store = MilvusDocumentStore(
      connection_args={"uri": "./milvus.db"},
      drop_old=True,
  )
  documents = [Document(
      content="A Foo Document",
      meta={"page": "100", "chapter": "intro"},
      embedding=[-10.0] * 128,
  )]
  document_store.write_documents(documents)
  print(document_store.count_documents())  # 1
  ```


  - For the case of [Milvus Lite](https://milvus.io/docs/milvus_lite.md), the most convenient method, just set the uri as a local file.
  ```python
  document_store = MilvusDocumentStore(
      connection_args={"uri": "./milvus.db"},
      drop_old=True,
  )
  ```

  - For the case of Milvus server on [docker or kubernetes](https://milvus.io/docs/quickstart.md), it is recommended to use when you are dealing with large scale of data. After starting the Milvus service, you can use the specified uri to connect to the service.
  ```python
  document_store = MilvusDocumentStore(
      connection_args={"uri": "http://localhost:19530"},
      drop_old=True,
  )
  ```

  - For the case of [Zilliz Cloud](https://zilliz.com/cloud), the fully managed cloud service for Milvus, adjust the uri and token, which correspond to the [Public Endpoint and Api key](https://docs.zilliz.com/docs/on-zilliz-cloud-console#free-cluster-details) in Zilliz Cloud.
  ```python
  from haystack.utils import Secret
  document_store = MilvusDocumentStore(
      connection_args={
          "uri": "https://in03-ba4234asae.api.gcp-us-west1.zillizcloud.com",  # Your Public Endpoint
          "token": Secret.from_env_var("ZILLIZ_CLOUD_API_KEY"),  # API key, we recommend using the Secret class to load the token from env variable for security.
          "secure": True
      },
      drop_old=True,
  )
  ```





  Prepare an OpenAI API key and set it as an environment variable:

  ```shell
  export OPENAI_API_KEY=<your_api_key>
  ```



  ```python
  import glob
  import os

  from haystack import Pipeline
  from haystack.components.converters import MarkdownToDocument
  from haystack.components.embedders import OpenAIDocumentEmbedder, OpenAITextEmbedder
  from haystack.components.preprocessors import DocumentSplitter
  from haystack.components.writers import DocumentWriter

  from milvus_haystack import MilvusDocumentStore
  from milvus_haystack.milvus_embedding_retriever import MilvusEmbeddingRetriever

  current_file_path = os.path.abspath(__file__)
  file_paths = [current_file_path]  # You can replace it with your own file paths.

  document_store = MilvusDocumentStore(
      connection_args={"uri": "./milvus.db"},
      drop_old=True,
  )
  indexing_pipeline = Pipeline()
  indexing_pipeline.add_component("converter", MarkdownToDocument())
  indexing_pipeline.add_component("splitter", DocumentSplitter(split_by="sentence", split_length=2))
  indexing_pipeline.add_component("embedder", OpenAIDocumentEmbedder())
  indexing_pipeline.add_component("writer", DocumentWriter(document_store))
  indexing_pipeline.connect("converter", "splitter")
  indexing_pipeline.connect("splitter", "embedder")
  indexing_pipeline.connect("embedder", "writer")
  indexing_pipeline.run({"converter": {"sources": file_paths}})

  print("Number of documents:", document_store.count_documents())
  ```



  ```python
  question = "How to set the service uri with milvus lite?"  # You can replace it with your own question.

  retrieval_pipeline = Pipeline()
  retrieval_pipeline.add_component("embedder", OpenAITextEmbedder())
  retrieval_pipeline.add_component("retriever", MilvusEmbeddingRetriever(document_store=document_store, top_k=3))
  retrieval_pipeline.connect("embedder", "retriever")

  retrieval_results = retrieval_pipeline.run({"embedder": {"text": question}})

  for doc in retrieval_results["retriever"]["documents"]:
      print(doc.content)
      print("-" * 10)
  ```



  ```python
  from haystack.utils import Secret
  from haystack.components.builders import PromptBuilder
  from haystack.components.generators import OpenAIGenerator

  prompt_template = """Answer the following query based on the provided context. If the context does
                       not include an answer, reply with 'I don't know'.\n
                       Query: {{query}}
                       Documents:
                       {% for doc in documents %}
                          {{ doc.content }}
                       {% endfor %}
                       Answer:
                    """

  rag_pipeline = Pipeline()
  rag_pipeline.add_component("text_embedder", OpenAITextEmbedder())
  rag_pipeline.add_component("retriever", MilvusEmbeddingRetriever(document_store=document_store, top_k=3))
  rag_pipeline.add_component("prompt_builder", PromptBuilder(template=prompt_template))
  rag_pipeline.add_component("generator", OpenAIGenerator(api_key=Secret.from_token(os.getenv("OPENAI_API_KEY")),
                                                          generation_kwargs={"temperature": 0}))
  rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
  rag_pipeline.connect("retriever.documents", "prompt_builder.documents")
  rag_pipeline.connect("prompt_builder", "generator")

  results = rag_pipeline.run(
      {
          "text_embedder": {"text": question},
          "prompt_builder": {"query": question},
      }
  )
  print('RAG answer:', results["generator"]["replies"][0])

  ```


  ```python
  from haystack import Document, Pipeline
  from haystack.components.writers import DocumentWriter
  from haystack.document_stores.types import DuplicatePolicy
  from haystack_integrations.components.embedders.fastembed import (
      FastembedSparseDocumentEmbedder,
      FastembedSparseTextEmbedder,
  )

  from milvus_haystack import MilvusDocumentStore, MilvusSparseEmbeddingRetriever

  document_store = MilvusDocumentStore(
      connection_args={"uri": "./milvus.db"},
      sparse_vector_field="sparse_vector",  # Specify a name of the sparse vector field to enable sparse retrieval.
      drop_old=True,
  )

  documents = [
      Document(content="My name is Wolfgang and I live in Berlin"),
      Document(content="I saw a black horse running"),
      Document(content="Germany has many big cities"),
      Document(content="fastembed is supported by and maintained by Milvus."),
  ]

  sparse_document_embedder = FastembedSparseDocumentEmbedder()
  writer = DocumentWriter(document_store=document_store, policy=DuplicatePolicy.OVERWRITE)

  indexing_pipeline = Pipeline()
  indexing_pipeline.add_component("sparse_document_embedder", sparse_document_embedder)
  indexing_pipeline.add_component("writer", writer)
  indexing_pipeline.connect("sparse_document_embedder", "writer")

  indexing_pipeline.run({"sparse_document_embedder": {"documents": documents}})

  query_pipeline = Pipeline()
  query_pipeline.add_component("sparse_text_embedder", FastembedSparseTextEmbedder())
  query_pipeline.add_component("sparse_retriever", MilvusSparseEmbeddingRetriever(document_store=document_store))
  query_pipeline.connect("sparse_text_embedder.sparse_embedding", "sparse_retriever.query_sparse_embedding")

  query = "Who supports fastembed?"

  result = query_pipeline.run({"sparse_text_embedder": {"text": query}})

  print(result["sparse_retriever"]["documents"][0])


  ```



  ```python
  from haystack import Document, Pipeline
  from haystack.components.embedders import OpenAIDocumentEmbedder, OpenAITextEmbedder
  from haystack.components.writers import DocumentWriter
  from haystack.document_stores.types import DuplicatePolicy
  from haystack_integrations.components.embedders.fastembed import (
      FastembedSparseDocumentEmbedder,
      FastembedSparseTextEmbedder,
  )

  from milvus_haystack import MilvusDocumentStore, MilvusHybridRetriever

  document_store = MilvusDocumentStore(
      connection_args={"uri": "./milvus.db"},
      drop_old=True,
      sparse_vector_field="sparse_vector",  # Specify a name of the sparse vector field to enable hybrid retrieval.
  )

  documents = [
      Document(content="My name is Wolfgang and I live in Berlin"),
      Document(content="I saw a black horse running"),
      Document(content="Germany has many big cities"),
      Document(content="fastembed is supported by and maintained by Milvus."),
  ]

  writer = DocumentWriter(document_store=document_store, policy=DuplicatePolicy.OVERWRITE)

  indexing_pipeline = Pipeline()
  indexing_pipeline.add_component("sparse_doc_embedder", FastembedSparseDocumentEmbedder())
  indexing_pipeline.add_component("dense_doc_embedder", OpenAIDocumentEmbedder())
  indexing_pipeline.add_component("writer", writer)
  indexing_pipeline.connect("sparse_doc_embedder", "dense_doc_embedder")
  indexing_pipeline.connect("dense_doc_embedder", "writer")

  indexing_pipeline.run({"sparse_doc_embedder": {"documents": documents}})

  querying_pipeline = Pipeline()
  querying_pipeline.add_component("sparse_text_embedder",
                                  FastembedSparseTextEmbedder(model="prithvida/Splade_PP_en_v1"))

  querying_pipeline.add_component("dense_text_embedder", OpenAITextEmbedder())
  querying_pipeline.add_component(
      "retriever",
      MilvusHybridRetriever(
          document_store=document_store,
          
      )
  )

  querying_pipeline.connect("sparse_text_embedder.sparse_embedding", "retriever.query_sparse_embedding")
  querying_pipeline.connect("dense_text_embedder.embedding", "retriever.query_embedding")

  question = "Who supports fastembed?"

  results = querying_pipeline.run(
      {"dense_text_embedder": {"text": question},
       "sparse_text_embedder": {"text": question}}
  )

  print(results["retriever"]["documents"][0])



  ```


  `milvus-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.


pkgId: f17549e8bbf6a2e07380732dc61189dc191d7a1f1fe96bb3b59c2437a936c6dc
name: python-minGRU-pytorch-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for minGRU-pytorch
url: https://pypi.org/project/minGRU-pytorch/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-minGRU-pytorch-0.1.1-1.src.rpm
location_href: Packages/python-minGRU-pytorch-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Implementation of the proposed <a href="https://arxiv.org/abs/2410.01201v1">minGRU</a> in Pytorch, only the log-space numerically stable version.

  <a href="https://www.youtube.com/watch?v=jE9jAZC42NE">Yannic's paper review</a>



  ```bash
  $ pip install minGRU-pytorch
  ```



  ```python
  import torch
  from minGRU_pytorch import minGRU

  min_gru = minGRU(512)

  x = torch.randn(2, 1024, 512)

  out = min_gru(x)

  assert x.shape == out.shape
  ```

  Sanity check

  ```python
  import torch
  from minGRU_pytorch import minGRU

  min_gru = minGRU(dim = 512, expansion_factor = 1.5)

  x = torch.randn(1, 2048, 512)



  parallel_out = min_gru(x)[:, -1:]



  prev_hidden = None
  for token in x.unbind(dim = 1):
      sequential_out, prev_hidden = min_gru(token[:, None, :], prev_hidden, return_next_prev_hidden = True)

  assert torch.allclose(parallel_out, sequential_out, atol = 1e-4)
  ```



  enwik8

  ```bash
  $ python train.py
  ```



  ```bibtex
  @inproceedings{Feng2024WereRA,
      title   = {Were RNNs All We Needed?},
      author  = {Leo Feng and Frederick Tung and Mohamed Osama Ahmed and Yoshua Bengio and Hossein Hajimirsadegh},
      year    = {2024},
      url     = {https://api.semanticscholar.org/CorpusID:273025630}
  }
  ```

  ```bibtex
  @inproceedings{anonymous2024hymba,
      title   = {Hymba: A Hybrid-head Architecture for Small Language Models},
      author  = {Anonymous},
      booktitle = {Submitted to The Thirteenth International Conference on Learning Representations},
      year    = {2024},
      url     = {https://openreview.net/forum?id=A1ztozypga},
      note    = {under review}
  }
  ```

rpm_license:
[cell repeats an earlier one in this file: 1065 characters]


pkgId: 011fd7f02032dc8aa3d3f7cae015d01c72e7d1a6280a18c7d062808c1122355c
name: python-mindbotai-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for mindbotai
url: https://github.com/AetherMind-Ai/mindbotlibrary
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mindbotai-0.1-1.src.rpm
location_href: Packages/python-mindbotai-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains a set of functions for interacting with (MindBot) for tasks like generating content, summarizing videos, and more.



  To install the package, use pip:

  ```bash
  pip install mindbotai


pkgId: e6190d2ba02cca9d77eadf6d7a62582340e90eac2a7fbaa10018cd105d6a53c2
name: python-mindee-help
arch: noarch
version: 4.16.0
epoch: 0
release: 1
summary: Development documents and examples for mindee
url: https://www.mindee.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mindee-4.16.0-1.src.rpm
location_href: Packages/python-mindee-help-4.16.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/github/license/mindee/mindee-api-python)](https://opensource.org/licenses/MIT) [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/mindee/mindee-api-python/unit-test.yml)](https://github.com/mindee/mindee-api-python) [![PyPI Version](https://img.shields.io/pypi/v/mindee)](https://pypi.org/project/mindee/) [![Downloads](https://img.shields.io/pypi/dm/mindee)](https://pypi.org/project/mindee/)


  Quickly and easily connect to Mindee's API services using Python.


  Here's the TL;DR of getting started.

  First, get an [API Key](https://developers.mindee.com/docs/create-api-key)

  Then, install this library:
  ```shell
  pip install mindee
  ```

  Finally, Python away!




  ```python
  from mindee import Client, product


  mindee_client = Client(api_key="my-api-key")


  input_doc = mindee_client.source_from_path("/path/to/the/file.ext")


  result = mindee_client.parse(product.InvoiceV4, input_doc)


  print(result.document)
  ```

  **Note:** Files can also be loaded from:

  A python `BinaryIO` compatible file:
  ```python
  input_doc = mindee_client.source_from_file(my_file)
  ```

  A URL (`HTTPS` only):
  ```python
  input_doc = mindee_client.source_from_url("https://files.readme.io/a74eaa5-c8e283b-sample_invoice.jpeg")
  ```

  A base64-encoded string, making sure to specify the extension of the file name:
  ```python
  input_doc = mindee_client.source_from_b64string(my_input_string, "my-file-name.ext")
  ```

  Raw bytes, making sure to specify the extension of the file name:
  ```python
  input_doc = mindee_client.source_from_bytes(my_raw_bytes_sequence, "my-file-name.ext")
  ```


  ```python
  from mindee import Client, product


  mindee_client = Client(api_key="my-api-key")


  input_doc = mindee_client.source_from_path("/path/to/the/file.ext")


  result = mindee_client.parse(product.us.BankCheckV1, input_doc)


  print(result.document)
  ```



  ```python
  from mindee import Client, product


  mindee_client = Client(api_key="my-api-key")


  my_endpoint = mindee_client.create_endpoint(
      account_name="my-account",
      endpoint_name="my-endpoint",
  )


  input_doc = mindee_client.source_from_path("/path/to/the/file.ext")



  result = mindee_client.enqueue_and_parse(
      product.GeneratedV1,
      input_doc,
      endpoint=my_endpoint
  )


  print(result.document)


  for field_name, field_values in result.document.fields.items():
      print(field_name, "=", field_values)
  ```


  Options to pass when sending a file.


  Allows sending only certain pages in a PDF.

  In this example we only send the first, penultimate and last pages:

  ```python
  from mindee import Client, product, PageOptions

  result = mindee_client.parse(
      product.InvoiceV4,
      input_source,
      page_options=PageOptions(
          page_indexes=[0, -2, -1],
          operation=PageOptions.KEEP_ONLY,
          on_min_pages=2
      )
  )
  ```


  Complete details on the working of the library are available in the following guides:

  * [Getting started](https://developers.mindee.com/docs/python-getting-started)
  * [Python Command Line Interface (CLI)](https://developers.mindee.com/docs/python-cli)
  * [Python Generated](https://developers.mindee.com/docs/generated-api-python)
  * [Python Custom APIs (Deprecated - API Builder)](https://developers.mindee.com/docs/python-api-builder)
  * [Python Invoice OCR](https://developers.mindee.com/docs/python-invoice-ocr)
  * [Python International Id OCR](https://developers.mindee.com/docs/python-international-id-ocr)
  * [Python Resume OCR](https://developers.mindee.com/docs/python-resume-ocr)
  * [Python Receipt OCR](https://developers.mindee.com/docs/python-receipt-ocr)
  * [Python Financial Document OCR](https://developers.mindee.com/docs/python-financial-document-ocr)
  * [Python Passport OCR](https://developers.mindee.com/docs/python-passport-ocr)
  * [Python Proof of Address OCR](https://developers.mindee.com/docs/python-proof-of-address-ocr)
  * [Python EU License Plate OCR](https://developers.mindee.com/docs/python-eu-license-plate-ocr)
  * [Python US Driver License OCR](https://developers.mindee.com/docs/python-eu-driver-license-ocr)
  * [Python FR Bank Account Detail OCR](https://developers.mindee.com/docs/python-fr-bank-account-details-ocr)
  * [Python FR Carte Grise OCR](https://developers.mindee.com/docs/python-fr-carte-grise-ocr)
  * [Python FR Health Card OCR](https://developers.mindee.com/docs/python-fr-health-card-ocr)
  * [Python FR ID Card OCR](https://developers.mindee.com/docs/python-fr-carte-nationale-didentite-ocr)
  * [Python FR Petrol Receipts OCR](https://developers.mindee.com/docs/python-fr-petrol-receipts-ocr)
  * [Python US Bank Check OCR](https://developers.mindee.com/docs/python-us-bank-check-ocr)
  * [Python US W9 OCR](https://developers.mindee.com/docs/python-us-w9-ocr)
  * [Python US Driver License OCR](https://developers.mindee.com/docs/python-us-driver-license-ocr)
  * [Python Barcode Reader API](https://developers.mindee.com/docs/python-barcode-reader-ocr)
  * [Python Cropper API](https://developers.mindee.com/docs/python-cropper-ocr)
  * [Python Invoice Splitter API](https://developers.mindee.com/docs/python-invoice-splitter-api)
  * [Python Multi Receipts Detector API](https://developers.mindee.com/docs/python-multi-receipts-detector-ocr)

  You can view the source code on [GitHub](https://github.com/mindee/mindee-api-python).

  You can also take a look at the
  **[Reference Documentation](https://mindee.github.io/mindee-api-python/)**.


  Copyright © Mindee

  Available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).


  [Join our Slack](https://join.slack.com/t/mindee-community/shared_invite/zt-2d0ds7dtz-DPAF81ZqTy20chsYpQBW5g)

rpm_license:
  MIT License  Copyright (c) 2021-Present Mindee  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: d86ec3053c59cc1b5a09aabc16e67a551357e6e0569e9228185a48d485d0d140
name: python-mindlessgen-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for mindlessgen
url: https://pypi.org/project/mindlessgen/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mindlessgen-0.5.1-1.src.rpm
location_href: Packages/python-mindlessgen-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/grimme-lab/MindlessGen/actions/workflows/ci.yml/badge.svg)
  <a href="http://www.apache.org/licenses/LICENSE-2.0">
    <img src="https://img.shields.io/badge/License-Apache%202.0-orange.svg" alt="Apache-2.0"/>
  </a>
  <a href="https://img.shields.io/badge/Python-3.10%20|%203.11%20|%203.12%20|%203.13-blue.svg">
    <img src="https://img.shields.io/badge/Python-3.10%20|%203.11%20|%203.12%20|%203.13-blue.svg" alt="Python Versions"/>
  </a>
  <img align="right" src="assets/C1H2N1O2Te2Er1Lu2_89bd3e.png" height="150" />

  `mindlessgen` is a Python-based program for semi-automated generation of "mindless" small molecules, as described [here](https://pubs.acs.org/doi/full/10.1021/ct800511q).
  The rule-based algorithm places atoms randomly in coordinate space and applies several optimization, fragment detection, and sanity check steps.
  The program is mainly controlled via a [TOML](https://github.com/grimme-lab/MindlessGen/blob/main/mindlessgen.toml) configuration file, see below for details.



  ![One-pager overview](assets/MindlessGen_SingleSlide.png)



  > [!IMPORTANT]
  > `xtb` (see [here](https://github.com/grimme-lab/xtb)) has to be installed on your system, either via `conda-forge`, as a release binary, or compiled from source.
  If post-processing with DFT is desired, also `orca` (see [here](https://www.faccts.de/docs/orca/6.0/manual/index.html)) has to be available.



  You can install the project in an existing virtual environment (provided for example by the package managers `conda` or `mamba` (see also [here](https://github.com/conda-forge/miniforge) and [here](https://conda.io/projects/conda/en/latest/user-guide/getting-started.html))).
  With `mamba`, a matching Python environment can be set up and activated as follows:
  ```
  mamba create -n mindlessgen python=3.12
  mamba activate mindlessgen
  ```

  Afterwards, the package can be installed by downloading the package from `PyPi`:
  ```bash
  pip install mindlessgen
  ```
  This command installs the latest release version of `mindlessgen`.

  Alternatively, it can be installed from the latest source code via cloning the repository:
  ```bash
  git clone https://github.com/grimme-lab/MindlessGen.git # or the analogous SSH link
  pip install .
  ```

  Both installation methods work in principle also without a virtual environment, but it is strongly recommended to use one to avoid conflicts with other packages.



  For working on the code of `mindlessgen`, the following setup is recommended:
  ```bash
  mamba create -n mindlessgen python=3.12
  mamba activate mindlessgen
  git clone https://github.com/grimme-lab/MindlessGen.git # or the analogous SSH link
  pip install -e '.[dev]'
  ```
  Thereby, all necessary development tools (e.g., `ruff`, `mypy`, `tox`, `pytest`, and `pre-commit`) are installed.
  Before making changes to the code, activate the `pre-commit` hooks via:
  ```
  pre-commit install
  ```
  Before pushing a commit, run the optional tests, which depend on external dependencies like `xtb`, via
  ```
  pytest -vv --optional
  ```
  Further information on how to contribute to this project can also be found in the [contribution guidelines](https://github.com/grimme-lab/MindlessGen/blob/main/CONTRIBUTING.md).





  > [!WARNING]
  > `mindlessgen` may still be subject to API changes.

  `mindlessgen` can be executed after installation in the desired environment via:
  ```
  mindlessgen -h
  ```
  This command displays all command line options in the terminal.
  In addition, all commands are accessible via the [TOML](https://github.com/grimme-lab/MindlessGen/blob/main/mindlessgen.toml) configuration file.
  The template configuration file in the root directory of the repository contains comprehensive explanations for each of the available configuration keys.
  If the path is not specified with `-c/--config`, `mindlessgen.toml` will be searched in the following locations, in order:
  1. Current working directory (`$CWD`)
  2. Home directory (`$USER/`)

  If neither a corresponding CLI command nor an entry in the configuration file is provided, the default values are used.
  The active configuration, including the default values, can be printed using `--print-config`.


  There are two related aspects of the element composition:
  1. **Which elements** should occur within the generated molecule?
  2. **How many atoms** of the specified element should occur?
  - **Example 1**: `C:1-3, O:1-1, H:1-*` would result in a molecule with 1, 2, or 3 carbon atoms, exactly 1 oxygen atom, and between 1 and an undefined number of hydrogen atoms (i.e., at least 1).
  - **Example 2**: `Na:10-10, In:10-10, O:20-20`. This example would result in a molecule with exactly 10 sodium atoms, 10 indium atoms, and 20 oxygen atoms.
  For fixing the whole molecule to this composition, set `fixed_composition` to `true`.
  `mindlessgen` will consequently always return a molecule with exactly 40 atoms.

  > [!WARNING]
  > When using `orca` and specifying elements with `Z > 86`, ensure that the basis set you've selected is compatible with (super-)heavy elements like actinides.
  > You can find a list of available basis sets [here](https://www.faccts.de/docs/orca/6.0/manual/contents/detailed/basisset.html#built-in-basis-sets).
  > A reliable standard choice that covers the entire periodic table is `def2-mTZVPP`.



  ```python
  """
  Python script that calls the MindlessGen API.
  """

  import warnings

  from mindlessgen.generator import generator
  from mindlessgen.prog import ConfigManager


  def main():
      """
      Main function for execution of MindlessGen via Python API.
      """
      config = ConfigManager()

      
      config.general.max_cycles = 500
      config.general.parallel = 6
      config.general.verbosity = -1
      config.general.num_molecules = 2
      config.general.postprocess = False
      config.general.write_xyz = False

      
      config.generate.min_num_atoms = 10
      config.generate.max_num_atoms = 15
      config.generate.element_composition = "Ce:1-1"
      
      config.generate.forbidden_elements = "21-30,39-48,57-80"
      

      
      config.xtb.level = 1

      try:
          molecules, exitcode = generator(config)
      except RuntimeError as e:
          print(f"\nGeneration failed: {e}")
          raise RuntimeError("Generation failed.") from e
      if exitcode != 0:
          warnings.warn("Generation completed with errors for parts of the generation.")
      for molecule in molecules:
          molecule.write_xyz_to_file()
          print(
              "\n###############\nProperties of molecule "
              + f"'{molecule.name}' with formula {molecule.sum_formula()}:"
          )
          print(molecule)


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



  When using the program for academic purposes, please cite _i)_ the original idea and _ii)_ the new Python implementation.

  1.  _J. Chem. Theory Comput._ 2009, **5**, 4, 993–1003
      ```
      @article{korth_mindless_2009,
      	title = {Mindless {DFT} benchmarking},
      	volume = {5},
      	issn = {15499618},
      	url = {https://pubs.acs.org/doi/full/10.1021/ct800511q},
      	doi = {10.1021/ct800511q},
      	number = {4},
      	urldate = {2022-11-07},
      	journal = {J. Chem. Theo. Comp.},
      	author = {Korth, Martin and Grimme, Stefan},
      	month = apr,
      	year = {2009},
      	note = {Publisher: American Chemical Society},
      	pages = {993--1003},
      }
      ```

  2.  A new publication featuring all functionalities and improvements of `mindlessgen` is in preparation.
      In the meantime, please refer to the original publication and to the following publication, which uses the `mindlessgen` program for the first time:
      Marcel Müller, Thomas Froitzheim, Andreas Hansen, and Stefan Grimme, *The Journal of Physical Chemistry A* **2024** *128* (49), 10723-10736, DOI: 10.1021/acs.jpca.4c06989.
      ```
      @article{
          doi:10.1021/acs.jpca.4c06989,
          author = {M{\"u}ller, Marcel and Froitzheim, Thomas and Hansen, Andreas and Grimme, Stefan},
          title = {Advanced Charge Extended Hückel (CEH) Model and a Consistent Adaptive Minimal Basis Set for the Elements Z = 1–103},
          journal = {The Journal of Physical Chemistry A},
          volume = {128},
          number = {49},
          pages = {10723-10736},
          year = {2024},
          doi = {10.1021/acs.jpca.4c06989},
          note ={PMID: 39621818},
          URL = {https://doi.org/10.1021/acs.jpca.4c06989},
          eprint = {https://doi.org/10.1021/acs.jpca.4c06989}
      }
      ```



  [T. Gasevic](https://github.com/gasevic) for creating an initial `GitHub` [migration](https://github.com/gasevic/mlmgen) of the code and making important adjustments to the workflow.
  [S. Grimme](https://www.chemie.uni-bonn.de/grimme/de/grimme) and M. Korth for the original code written in Fortran associated to the publication in [J. Chem. Theory Comput.](https://pubs.acs.org/doi/full/10.1021/ct800511q).
  [T. Froitzheim](https://github.com/thfroitzheim) for helpful discussons during the development of the program.


pkgId: cfaa9651a33154235a238bd3d190a93b0a1481cae31dea789dc3ec8f35bab565
name: python-minet-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for minet
url: http://github.com/medialab/minet
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-minet-3.2.0-1.src.rpm
location_href: Packages/python-minet-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/medialab/minet/workflows/Tests/badge.svg)](https://github.com/medialab/minet/actions) [![DOI](https://zenodo.org/badge/169059797.svg)](https://zenodo.org/badge/latestdoi/169059797) [![download number](https://static.pepy.tech/badge/minet)](https://pepy.tech/project/minet)

  ![Minet](docs/img/minet.png)

  **minet** is a webmining command line tool & library for python (>= 3.7) that can be used to collect and extract data from a large variety of web sources such as raw webpages, Facebook, YouTube, Twitter, Media Cloud etc.

  It adopts a very simple approach to various webmining problems by letting you perform a wide array of tasks from the comfort of the command line. No database needed: raw CSV files should be sufficient to do most of the work.

  In addition, **minet** also exposes its high-level programmatic interface as a python library so you remain free to use its utilities to suit your use-cases better.

  **minet** is developed by [médialab SciencesPo](https://github.com/medialab/) research engineers and is the consolidation of more than a decade of webmining practices targeted at social sciences.

  As such, it has been designed to be:

  1. **low-tech**, as it requires minimal resources such as memory, CPUs or hard drive space and should be able to work on any low-cost PC.
  2. **fault-tolerant**, as it is able to recover when network is bad and retry HTTP calls when suitable. What's more, most of minet commands can be resumed if aborted and are designed to run for a long time (think days or months) without leaking memory.
  3. **unix-compliant**, as it can be piped easily and know how to work with the usual streams.

  **Shortcuts**: [Command line documentation](./docs/cli.md), [Python library documentation](./docs/lib.md).

  ![fetch](./docs/img/fetch.gif)

  _How to cite?_

  **minet** is published on [Zenodo](https://zenodo.org/) as [10.5281/zenodo.4564399](http://doi.org/10.5281/zenodo.4564399).

  You can cite it thusly:

  > Guillaume Plique, Pauline Breteau, Jules Farjas, Héloïse Théro, Jean Descamps, Amélie Pellé, Laura Miguel, César Pichon, & Kelly Christensen. (2019, October 14). Minet, a webmining CLI tool & library for python. Zenodo. http://doi.org/10.5281/zenodo.4564399



  ```bash

  minet fetch url -i urls.csv > report.csv


  minet extract -i report.csv -I downloaded > extracted.csv


  minet scrape urls -i report.csv -I downloaded > scraped_urls.csv


  minet url-parse scraped_url -i scraped_urls.csv > parsed_urls.csv


  minet twitter scrape tweets "from:medialab_ScPo" > tweets.csv


  minet twitter scrape -h


  minet youtube search -k "MY-YT-API-KEY" "médialab" > videos.csv
  ```



  - [What it does](#what-it-does)
  - [Documented use cases](#documented-use-cases)
  - [Features (from a technical standpoint)](#features-from-a-technical-standpoint)
  - [Installation](#installation)
  - [Upgrading](#upgrading)
  - [Uninstallation](#uninstallation)
  - [Documentation](#documentation)
  - [Contributing](#contributing)



  Minet can single-handedly:

  - Extract URLs from a text file (or a table)
  - Parse URLs (get useful information, with Facebook- and Youtube-specific stuff)
  - Join two CSV files by matching the columns containing URLs
  - From a list of URLs, resolve their redirections
    - ...and check their HTTP status
    - ...and download the HTML
    - ...and extract hyperlinks
    - ...and extract the text content and other metadata (title...)
    - ...and scrape structured data (using a declarative language to define your heuristics)
  - Crawl (using a declarative language to define a browsing behavior, and what to harvest)
  - Mine or search:
    - _[Mediacloud](https://mediacloud.org/)_ (requires free API access)
    - _[Twitter](https://twitter.com)_ (requires free API access)
    - _[Wikipedia](https://ww.wikipedia.org)_
    - _[Youtube](https://www.youtube.com/)_ (requires free API access)
  - Scrape (without requiring special access, often just a user account):
    - _[Facebook](https://www.facebook.com/)_
    - _[Instagram](https://www.instagram.com/)_
    - _[Telegram](https://telegram.org/)_
    - _[TikTok](https://www.tiktok.com)_
    - _[Twitter](https://twitter.com)_
    - _[Google Drive](https://drive.google.com)_ (spreadsheets etc.)
  - Grab & dump cookies from your browser
  - Dump _[Hyphe](https://hyphe.medialab.sciences-po.fr/)_ data



  - [Fetching a large amount of urls](./docs/cookbook/fetch.md)
  - [Joining 2 CSV files by urls](./docs/cookbook/url_join.md)
  - [Using minet from a Jupyter notebook](./docs/cookbook/notebooks/Minet%20in%20a%20Jupyter%20notebook.ipynb) (_very useful to experiment with the tool or teach students_)
  - [Downloading images associated with a given hashtag on Twitter](./docs/cookbook/twitter_images.md)
  - [Scraping DSL Tutorial](./docs/cookbook/scraping_dsl.md)



  - Multithreaded, memory-efficient fetching from the web.
  - Multithreaded, scalable crawling.
  - Multiprocessed raw text content extraction from HTML pages.
  - Multiprocessed scraping from HTML pages.
  - URL-related heuristics utilities such as extraction, normalization and matching.
  - Data collection from various APIs such as [YouTube](https://www.youtube.com/).



  **minet** can be installed as a standalone CLI tool (currently only on mac >= 10.14, ubuntu & similar) by running the following command in your terminal:

  ```shell
  curl -sSL https://raw.githubusercontent.com/medialab/minet/master/scripts/install.sh | bash
  ```

  Don't trust us enough to pipe the result of a HTTP request into `bash`? We wouldn't either, so feel free to read the installation script [here](./scripts/install.sh) and run it on your end if you prefer.

  On ubuntu & similar you might need to install `curl` and `unzip` before running the installation script if you don't already have it:

  ```shell
  sudo apt-get install curl unzip
  ```

  Else, **minet** can be installed directly as a python CLI tool and library using pip:

  ```shell
  pip install minet
  ```

  Finally if you want to install the standalone binaries by yourself (even for windows) you can find them in each release [here](https://github.com/medialab/minet/releases).



  To upgrade the standalone version, simply run the install script once again:

  ```shell
  curl -sSL https://raw.githubusercontent.com/medialab/minet/master/scripts/install.sh | bash
  ```

  To upgrade the python version you can use pip thusly:

  ```shell
  pip install -U minet
  ```



  To uninstall the standalone version:

  ```shell
  curl -sSL https://raw.githubusercontent.com/medialab/minet/master/scripts/uninstall.sh | bash
  ```

  To uninstall the python version:

  ```shell
  pip uninstall minet
  ```



  - [minet as a command line tool](./docs/cli.md)
  - [minet as a python library](./docs/lib.md)



  To contribute to **minet** you can check out [this](./CONTRIBUTING.md) documentation.


pkgId: 7a56bf2f40a4bd9dae49016878370434295fdc93d1231fd56897f067fa6d91f6
name: python-miniapi3-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for miniapi3
url: https://pypi.org/project/miniapi3/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-miniapi3-0.1.7-1.src.rpm
location_href: Packages/python-miniapi3-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  A lightweight Python web framework inspired by FastAPI, featuring async support, WebSocket capabilities, and middleware.



  [miniapi3](https://github.com/milisp/miniapi) ![PyPI Downloads](https://static.pepy.tech/badge/miniapi3)



  - Async request handling
  - Route parameters
  - WebSocket support
  - Middleware system
  - Request validation
  - CORS support
  - Form data handling
  - ASGI compatibility



  ```bash
  pip install miniapi3
  ```

  For WebSocket support:
  ```bash
  pip install miniapi3[websockets]
  ```


  ```python

  from miniapi3 import MiniAPI, Request

  app = MiniAPI()

  @app.get("/")
  async def hello():
      return {"message": "Hello, World!"}

  @app.get("/users/{user_id}")
  async def get_user(request: Request):
      user_id = request.path_params["user_id"]
      return {"user_id": user_id}


  @app.websocket("/ws")
  async def websocket_handler(ws):
      while True:
          message = await ws.receive()
          await ws.send(f"Echo: {message}")

  if __name__ == "__main__":
      app.run()
  ```



  ```bash
  uvicorn main:app
  ```



  ```bash
  pip install pydantic
  ```

  ```python
  from miniapi3 import MiniAPI
  from pydantic import BaseModel

  app = MiniAPI()

  class UserCreate(BaseModel):
      name: str

  @app.post("/users")
  async def create_user(user: UserCreate):
      return dict(user)
  ```




  ```python
  from miniapi3 import MiniAPI, CORSMiddleware

  app = MiniAPI()
  app.add_middleware(CORSMiddleware, allow_origins=["*"])
  ```




  ```python
  from miniapi3 import MiniAPI, html

  app = MiniAPI()

  @app.get("/")
  async def index():
      return html("<h1>Hello, World!</h1>")
  ```


pkgId: c13752118437a1321769268d9a82b55da2fb81266b1b11d066a270b82ccf8767
name: python-minibone-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for minibone
url: https://github.com/erromu/minibone/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-minibone-0.7.2-1.src.rpm
location_href: Packages/python-minibone-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Check](https://github.com/erromu/minibone/actions/workflows/python-check.yml/badge.svg)](https://github.com/erromu/minibone/actions/workflows/python-check.yml)  [![Deploy](https://github.com/erromu/minibone/actions/workflows/python-publish.yml/badge.svg)](https://github.com/erromu/minibone/actions/workflows/python-publish.yml) [![PyPI version](https://badge.fury.io/py/minibone.svg)](https://pypi.org/project/minibone)

  minibone is an easy to use yet powerful boiler plate for multithreading, multiprocessing and others:

  - __Config__: To handle configuration settings
  - __Daemon__: To run a periodical task in another thread
  - __HTMLBase__: To render html using snippets and toml configuration file in async mode
  - __Logging__: To setup a logger friendly with filerotation
  - __PARProcesses__: To run parallel tasks as processes
  - __PARThreads__: To run parallel tasks in threads
  - __Storing__: To queue and store files periodically in a thread (queue and forget)
  - Among others (I will add more later)

  It will be deployed to PyPi when a new release is created



  ```shell

  pip install minibone

  ```



  Handle configuration settings in memory and/or persist them into toml/yaml/json formats

  ```python

  from minibone.config import Config


  cfg = Config(settings={"listen": "localhost", "port": 80}, filepath="config.toml")
  cfg.add("debug", True)
  cfg.to_toml()


  cfg2 = Config.from_toml("config.toml")


  import asyncio

  cfg3 = asyncio.run(Config.aiofrom_toml("config.toml"))
  ```

  Usually config files are editted externaly then loaded as read only on your code, so in such case, you may want to subclass Config for easier usage


  ```python

  from minibone.config import Config

  class MyConfig(Config):

      def __init__(self):
          defaults = {"main": {"listen": "localhost", "port": 80}}
          settings = Config.from_toml(filepath="config.toml", defaults=defaults)
          super().__init__(settings=settings)

      def listen(self) -> str:
          return self["main"]["listen"]

      def port(self) -> int:
          return self["main"]["port"]

  if __name__ == "__main__":
      cfg = MyConfig()
      print(cfg.port())
      

  ```



  It is just another python class to run a periodical task in another thread. It can be used in two modes: subclasing and callback



  - Subclass Daemon
  - call super().__init__() in yours
  - Overwrite on_process method with yours
  - Add logic you want to run inside on_process
  - Be sure your methods are safe-thread to avoid race condition
  - self.lock is available for lock.acquire / your_logic / lock.release
  - call start() method to keep running on_process in a new thread
  - call stop() to finish the thread

  Check [sample_clock.py](https://github.com/erromu/minibone/blob/main/src/minibone/sample_clock.py) for a sample



  - Instance Daemon by passing a callable
  - Add logic to your callable method
  - Be sure your callable is safe-thread to avoid race condition
  - call start() method to keep running callable in a new thread
  - call stop() to finish the thread

  Check [sample_clock_callback.py](https://github.com/erromu/minibone/blob/main/src/minibone/sample_clock_callback.py) for a sample



  Setup a logger using UTC time that outputs logs to stdin or to a file.
  It is friendly to filerotation (when setting output to a file)

  ```python

  import logging

  from minibone.logging import setup_log

  if __name__ == "__main__":

      
      

      setup_log(level="INFO")
      logging.info('This is a log to the stderr')

      
      
      

  ```



  - Feel free to clone this repository and send any pull requests.
  - Add issues if something is not working as expected.

rpm_license:
[cell repeats an earlier one in this file: 33880 characters]


pkgId: 8588c3f1ebd05c2b385c6b3d6444c370eab4f5f13ee0fd3e3ce61d5686ca2090
name: python-minim-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for minim
url: https://github.com/bbye98/minim
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-minim-1.0.0-1.src.rpm
location_href: Packages/python-minim-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <picture>
    <source media="(prefers-color-scheme: dark)"
     srcset="https://raw.githubusercontent.com/bbye98/minim/main/assets/logo_dark.svg">
    <source media="(prefers-color-scheme: light)"
     srcset="https://raw.githubusercontent.com/bbye98/minim/main/assets/logo_light.svg">
    <img alt="minim logo"
     src="https://raw.githubusercontent.com/bbye98/minim/main/assets/logo_light.svg">
  </picture>
  <br></br>



  [![continuous-integration](https://github.com/bbye98/minim/actions/workflows/ci.yml/badge.svg)](https://github.com/bbye98/minim/actions/workflows/ci.yml)

  Minim is a lightweight Python 3 library that can interface with APIs
  by popular music services—iTunes, Qobuz, Spotify, and TIDAL—and operate
  on audio files, such as updating metadata and converting between audio
  formats.

  * **Documentation**: https://bbye98.github.io/minim/



  * [`minim.audio`](https://github.com/bbye98/minim/blob/main/src/minim/audio.py):
    Audio file handlers for reading and writing metadata and converting
    between audio formats.
  * [`minim.itunes`](https://github.com/bbye98/minim/blob/main/src/minim/itunes.py):
    A client for the iTunes Search API.
  * [`minim.qobuz`](https://github.com/bbye98/minim/blob/main/src/minim/qobuz.py):
    A client for the Qobuz API with support for the password grant type
    for user authentication and user authentication token caching.
  * [`minim.spotify`](https://github.com/bbye98/minim/blob/main/src/minim/spotify.py):
    Clients for the Spotify Lyrics service and the Spotify Web API with
    support for the authorization code, authorization code with proof key
    for code exchange (PKCE), and client credentials grant types, and
    access token caching.
  * [`minim.tidal`](https://github.com/bbye98/minim/blob/main/src/minim/tidal.py):
    Clients for the old and new TIDAL APIs with support for the
    authorization code with PKCE and client credentials grant types, and
    access token caching.



  Minim requires Python 3.9 or later.

  Clone the repository and install the package using pip:

      git clone https://github.com/bbye98/minim.git
      cd minim
      python -m pip install -e .



  - Import Minim and create clients for the different APIs. Additional
    keyword arguments can be passed to the constructors to control user
    authentication.

        >>> from minim import itunes, qobuz, spotify, tidal
        >>> client_itunes = itunes.SearchAPI()
        >>> client_qobuz = qobuz.PrivateAPI()
        >>> client_spotify = spotify.WebAPI(flow="web_player")
        >>> client_tidal = tidal.PrivateAPI(client_id=<TIDAL_CLIENT_ID>)

  - Search for and retrieve information about an artist, such as the EDM
    group Galantis:

    **iTunes Search API**

        >>> client_itunes.search("Galantis", entity="musicArtist",
        ...                      limit=1)["results"][0]

    <details>
    <summary>Output</summary>

        {
          "wrapperType": "artist",
          "artistType": "Artist",
          "artistName": "Galantis",
          "artistLinkUrl": "https://music.apple.com/us/artist/galantis/543322169?uo=4",
          "artistId": 543322169,
          "amgArtistId": 2616267,
          "primaryGenreName": "Dance",
          "primaryGenreId": 17
        }

    </details>

    **Private Qobuz API**

        >>> client_qobuz.search("Galantis", limit=1,
        ...                     strict=True)["artists"]["items"][0]

    <details>
    <summary>Output</summary>

        {
          "picture": "https://static.qobuz.com/images/artists/covers/small/8dcf30e5c8e30281ecbb13b0886426c8.jpg",
          "image": {
            "small": "https://static.qobuz.com/images/artists/covers/small/8dcf30e5c8e30281ecbb13b0886426c8.jpg",
            "medium": "https://static.qobuz.com/images/artists/covers/medium/8dcf30e5c8e30281ecbb13b0886426c8.jpg",
            "large": "https://static.qobuz.com/images/artists/covers/large/8dcf30e5c8e30281ecbb13b0886426c8.jpg",
            "extralarge": "https://static.qobuz.com/images/artists/covers/large/8dcf30e5c8e30281ecbb13b0886426c8.jpg",
            "mega": "https://static.qobuz.com/images/artists/covers/large/8dcf30e5c8e30281ecbb13b0886426c8.jpg"
          },
          "name": "Galantis",
          "slug": "galantis",
          "albums_count": 126,
          "id": 865362
        }

    </details>

    **Spotify Web API**

        >>> client_spotify.search("Galantis", "artist", limit=1)["items"][0]

    <details>
    <summary>Output</summary>

        {
          "external_urls": {
            "spotify": "https://open.spotify.com/artist/4sTQVOfp9vEMCemLw50sbu"
          },
          "followers": {
            "href": null,
            "total": 3373205
          },
          "genres": [
            "dance pop",
            "edm",
            "pop",
            "pop dance"
          ],
          "href": "https://api.spotify.com/v1/artists/4sTQVOfp9vEMCemLw50sbu",
          "id": "4sTQVOfp9vEMCemLw50sbu",
          "images": [
            {
              "height": 640,
              "url": "https://i.scdn.co/image/ab6761610000e5eb7bda087d6fb48d481efd3344",
              "width": 640
            },
            {
              "height": 320,
              "url": "https://i.scdn.co/image/ab676161000051747bda087d6fb48d481efd3344",
              "width": 320
            },
            {
              "height": 160,
              "url": "https://i.scdn.co/image/ab6761610000f1787bda087d6fb48d481efd3344",
              "width": 160
            }
          ],
          "name": "Galantis",
          "popularity": 67,
          "type": "artist",
          "uri": "spotify:artist:4sTQVOfp9vEMCemLw50sbu"
        }

    </details>

    **Private TIDAL API**

        >>> client_tidal.search("Galantis", type="artist", limit=1)["items"][0]

    <details>
    <summary>Output</summary>

        {
          "id": 4676988,
          "name": "Galantis",
          "artistTypes": [
            "ARTIST",
            "CONTRIBUTOR"
          ],
          "url": "http://www.tidal.com/artist/4676988",
          "picture": "a627e21c-60f7-4e90-b2bb-e50b178c4f0b",
          "popularity": 72,
          "artistRoles": [
            {
              "categoryId": -1,
              "category": "Artist"
            },
            {
              "categoryId": 11,
              "category": "Performer"
            },
            {
              "categoryId": 3,
              "category": "Engineer"
            },
            {
              "categoryId": 10,
              "category": "Production team"
            },
            {
              "categoryId": 1,
              "category": "Producer"
            },
            {
              "categoryId": 2,
              "category": "Songwriter"
            }
          ],
          "mixes": {
            "ARTIST_MIX": "000202a7e72fd90d0c0df2ed56ddea"
          }
        }

    </details>

  - Search for and retrieve information about a track, such as "Everybody Talks" by Neon Trees:

    **iTunes Search API**

        >>> client_itunes.search("Everybody Talks", media="music",
        ...                      limit=1)["results"][0]

    <details>
    <summary>Output</summary>

        {
          "wrapperType": "track",
          "kind": "song",
          "artistId": 350172836,
          "collectionId": 1443469527,
          "trackId": 1443469581,
          "artistName": "Neon Trees",
          "collectionName": "Picture Show",
          "trackName": "Everybody Talks",
          "collectionCensoredName": "Picture Show",
          "trackCensoredName": "Everybody Talks",
          "artistViewUrl": "https://music.apple.com/us/artist/neon-trees/350172836?uo=4",
          "collectionViewUrl": "https://music.apple.com/us/album/everybody-talks/1443469527?i=1443469581&uo=4",
          "trackViewUrl": "https://music.apple.com/us/album/everybody-talks/1443469527?i=1443469581&uo=4",
          "previewUrl": "https://audio-ssl.itunes.apple.com/itunes-assets/AudioPreview122/v4/5c/29/bf/5c29bf6b-ca2c-4e8b-2be6-c51a282c7dae/mzaf_1255557534804450018.plus.aac.p.m4a",
          "artworkUrl30": "https://is1-ssl.mzstatic.com/image/thumb/Music115/v4/80/e3/95/80e39565-35f9-2496-c6f8-6572490c4a7b/12UMGIM12509.rgb.jpg/30x30bb.jpg",
          "artworkUrl60": "https://is1-ssl.mzstatic.com/image/thumb/Music115/v4/80/e3/95/80e39565-35f9-2496-c6f8-6572490c4a7b/12UMGIM12509.rgb.jpg/60x60bb.jpg",
          "artworkUrl100": "https://is1-ssl.mzstatic.com/image/thumb/Music115/v4/80/e3/95/80e39565-35f9-2496-c6f8-6572490c4a7b/12UMGIM12509.rgb.jpg/100x100bb.jpg",
          "collectionPrice": 6.99,
          "trackPrice": 1.29,
          "releaseDate": "2011-12-19T12:00:00Z",
          "collectionExplicitness": "explicit",
          "trackExplicitness": "explicit",
          "discCount": 1,
          "discNumber": 1,
          "trackCount": 12,
          "trackNumber": 3,
          "trackTimeMillis": 177280,
          "country": "USA",
          "currency": "USD",
          "primaryGenreName": "Alternative",
          "contentAdvisoryRating": "Explicit",
          "isStreamable": true
        }

    </details>

    **Private Qobuz API**

        >>> client_qobuz.search("Everybody Talks", "ReleaseName", limit=1,
        ...                     strict=True)["tracks"]["items"][0]

    <details>
    <summary>Output</summary>

        {
          "maximum_bit_depth": 16,
          "copyright": "\u2117 2011 UMG Recordings, Inc.",
          "performers": "Justin Meldal-Johnsen, Producer, Guitar, Additional Keyboards, Percussion, Programmer, AssociatedPerformer - Tim Pagnotta, ComposerLyricist - Greg Collins, Engineer, StudioPersonnel - Wesley Seidman, Asst. Recording Engineer, StudioPersonnel - Tyler Glenn, ComposerLyricist - Neon Trees, MainArtist - Matt Wiggers, Asst. Recording Engineer, StudioPersonnel - Bill Bush, Mixer, StudioPersonnel",
          "audio_info": {
            "replaygain_track_peak": 0.999969,
            "replaygain_track_gain": -11.63
          },
          "performer": {
            "name": "Neon Trees",
            "id": 470727
          },
          "album": {
            "image": {
              "small": "https://static.qobuz.com/images/covers/42/54/0060252795442_230.jpg",
              "thumbnail": "https://static.qobuz.com/images/covers/42/54/0060252795442_50.jpg",
              "large": "https://static.qobuz.com/images/covers/42/54/0060252795442_600.jpg"
            },
            "maximum_bit_depth": 16,
            "media_count": 1,
            "artist": {
              "image": null,
              "name": "Neon Trees",
              "id": 470727,
              "albums_count": 42,
              "slug": "neon-trees",
              "picture": null
            },
            "upc": "0060252795442",
            "released_at": 1325372400,
            "label": {
              "name": "Mercury Records",
              "id": 17487,
              "albums_count": 774,
              "supplier_id": 1,
              "slug": "mercury-records"
            },
            "title": "Picture Show",
            "qobuz_id": 5653617,
            "version": null,
            "duration": 2785,
            "parental_warning": true,
            "tracks_count": 11,
            "popularity": 0,
            "genre": {
              "path": [112, 119, 113],
              "color": "#0070ef",
              "name": "Alternative & Indie",
              "id": 113,
              "slug": "alternatif-et-inde"
            },
            "maximum_channel_count": 2,
            "id": "0060252795442",
            "maximum_sampling_rate": 44.1,
            "previewable": true,
            "sampleable": true,
            "displayable": true,
            "streamable": true,
            "streamable_at": 1683529200,
            "downloadable": false,
            "purchasable_at": null,
            "purchasable": false,
            "release_date_original": "2012-01-01",
            "release_date_download": "2012-01-01",
            "release_date_stream": "2012-01-01",
            "release_date_purchase": "2012-01-01",
            "hires": false,
            "hires_streamable": false
          },
          "work": null,
          "composer": {
            "name": "Tyler Glenn",
            "id": 583118
          },
          "isrc": "USUM71119189",
          "title": "Everybody Talks",
          "version": "Album Version",
          "duration": 177,
          "parental_warning": true,
          "track_number": 3,
          "maximum_channel_count": 2,
          "id": 5653620,
          "media_number": 1,
          "maximum_sampling_rate": 44.1,
          "release_date_original": null,
          "release_date_download": null,
          "release_date_stream": null,
          "release_date_purchase": null,
          "purchasable": true,
          "streamable": true,
          "previewable": true,
          "sampleable": true,
          "downloadable": true,
          "displayable": true,
          "purchasable_at": 1683702000,
          "streamable_at": 1683529200,
          "hires": false,
          "hires_streamable": false
        }

    </details>

    **Spotify Web API**

        >>> client_spotify.search("Everybody Talks", "track", limit=1)["items"][0]

    <details>
    <summary>Output</summary>

        {
          "album": {
            "album_type": "album",
            "artists": [
              {
                "external_urls": {
                  "spotify": "https://open.spotify.com/artist/0RpddSzUHfncUWNJXKOsjy"
                },
                "href": "https://api.spotify.com/v1/artists/0RpddSzUHfncUWNJXKOsjy",
                "id": "0RpddSzUHfncUWNJXKOsjy",
                "name": "Neon Trees",
                "type": "artist",
                "uri": "spotify:artist:0RpddSzUHfncUWNJXKOsjy"
              }
            ],
            "available_markets": [
              "AR", "AU", "AT", "BE", "BO", "BR", "BG",
              "CA", "CL", "CO", "CR", "CY", "CZ", "DK",
              "DO", "DE", "EC", "EE", "SV", "FI", "FR",
              "GR", "GT", "HN", "HK", "HU", "IS", "IE",
              "IT", "LV", "LT", "LU", "MY", "MT", "NL",
              "NZ", "NI", "NO", "PA", "PY", "PE", "PH",
              "PL", "PT", "SG", "SK", "ES", "SE", "CH",
              "TW", "TR", "UY", "US", "GB", "AD", "LI",
              "MC", "ID", "TH", "VN", "RO", "IL", "ZA",
              "SA", "AE", "BH", "QA", "OM", "KW", "EG",
              "TN", "LB", "JO", "PS", "IN", "BY", "KZ",
              "MD", "UA", "AL", "BA", "HR", "ME", "MK",
              "RS", "SI", "KR", "BD", "PK", "LK", "GH",
              "KE", "NG", "TZ", "UG", "AG", "AM", "BS",
              "BB", "BZ", "BT", "BW", "BF", "CV", "CW",
              "DM", "FJ", "GM", "GD", "GW", "GY", "HT",
              "JM", "KI", "LS", "LR", "MW", "MV", "ML",
              "MH", "FM", "NA", "NR", "NE", "PW", "PG",
              "WS", "ST", "SN", "SC", "SL", "SB", "KN",
              "LC", "VC", "SR", "TL", "TO", "TT", "TV",
              "AZ", "BN", "BI", "KH", "CM", "TD", "KM",
              "GQ", "SZ", "GA", "GN", "KG", "LA", "MO",
              "MR", "MN", "NP", "RW", "TG", "UZ", "ZW",
              "BJ", "MG", "MU", "MZ", "AO", "CI", "DJ",
              "ZM", "CD", "CG", "IQ", "TJ", "VE", "XK"
            ],
            "external_urls": {
              "spotify": "https://open.spotify.com/album/0uRFz92JmjwDbZbB7hEBIr"
            },
            "href": "https://api.spotify.com/v1/albums/0uRFz92JmjwDbZbB7hEBIr",
            "id": "0uRFz92JmjwDbZbB7hEBIr",
            "images": [
              {
                "height": 640,
                "url": "https://i.scdn.co/image/ab67616d0000b2734a6c0376235e5aa44e59d2c2",
                "width": 640
              },
              {
                "height": 300,
                "url": "https://i.scdn.co/image/ab67616d00001e024a6c0376235e5aa44e59d2c2",
                "width": 300
              },
              {
                "height": 64,
                "url": "https://i.scdn.co/image/ab67616d000048514a6c0376235e5aa44e59d2c2",
                "width": 64
              }
            ],
            "name": "Picture Show",
            "release_date": "2012-01-01",
            "release_date_precision": "day",
            "total_tracks": 11,
            "type": "album",
            "uri": "spotify:album:0uRFz92JmjwDbZbB7hEBIr"
          },
          "artists": [
            {
              "external_urls": {
                "spotify": "https://open.spotify.com/artist/0RpddSzUHfncUWNJXKOsjy"
              },
              "href": "https://api.spotify.com/v1/artists/0RpddSzUHfncUWNJXKOsjy",
              "id": "0RpddSzUHfncUWNJXKOsjy",
              "name": "Neon Trees",
              "type": "artist",
              "uri": "spotify:artist:0RpddSzUHfncUWNJXKOsjy"
            }
          ],
          "available_markets": [
            "AR", "AU", "AT", "BE", "BO", "BR", "BG",
            "CA", "CL", "CO", "CR", "CY", "CZ", "DK",
            "DO", "DE", "EC", "EE", "SV", "FI", "FR",
            "GR", "GT", "HN", "HK", "HU", "IS", "IE",
            "IT", "LV", "LT", "LU", "MY", "MT", "NL",
            "NZ", "NI", "NO", "PA", "PY", "PE", "PH",
            "PL", "PT", "SG", "SK", "ES", "SE", "CH",
            "TW", "TR", "UY", "US", "GB", "AD", "LI",
            "MC", "ID", "TH", "VN", "RO", "IL", "ZA",
            "SA", "AE", "BH", "QA", "OM", "KW", "EG",
            "TN", "LB", "JO", "PS", "IN", "BY", "KZ",
            "MD", "UA", "AL", "BA", "HR", "ME", "MK",
            "RS", "SI", "KR", "BD", "PK", "LK", "GH",
            "KE", "NG", "TZ", "UG", "AG", "AM", "BS",
            "BB", "BZ", "BT", "BW", "BF", "CV", "CW",
            "DM", "FJ", "GM", "GD", "GW", "GY", "HT",
            "JM", "KI", "LS", "LR", "MW", "MV", "ML",
            "MH", "FM", "NA", "NR", "NE", "PW", "PG",
            "WS", "ST", "SN", "SC", "SL", "SB", "KN",
            "LC", "VC", "SR", "TL", "TO", "TT", "TV",
            "AZ", "BN", "BI", "KH", "CM", "TD", "KM",
            "GQ", "SZ", "GA", "GN", "KG", "LA", "MO",
            "MR", "MN", "NP", "RW", "TG", "UZ", "ZW",
            "BJ", "MG", "MU", "MZ", "AO", "CI", "DJ",
            "ZM", "CD", "CG", "IQ", "TJ", "VE", "XK"
          ],
          "disc_number": 1,
          "duration_ms": 177280,
          "explicit": true,
          "external_ids": {
            "isrc": "USUM71119189"
          },
          "external_urls": {
            "spotify": "https://open.spotify.com/track/2iUmqdfGZcHIhS3b9E9EWq"
          },
          "href": "https://api.spotify.com/v1/tracks/2iUmqdfGZcHIhS3b9E9EWq",
          "id": "2iUmqdfGZcHIhS3b9E9EWq",
          "is_local": false,
          "name": "Everybody Talks",
          "popularity": 81,
          "preview_url": null,
          "track_number": 3,
          "type": "track",
          "uri": "spotify:track:2iUmqdfGZcHIhS3b9E9EWq"
        }

    </details>

    **Private TIDAL API**

        >>> client_tidal.search("Everybody Talks", type="track",
        ...                     limit=1)["items"][0]

    <details>
    <summary>Output</summary>

        {
          "id": 14492425,
          "title": "Everybody Talks",
          "duration": 177,
          "replayGain": -11.7,
          "peak": 0.999969,
          "allowStreaming": true,
          "streamReady": true,
          "adSupportedStreamReady": true,
          "djReady": true,
          "stemReady": false,
          "streamStartDate": "2012-04-17T00:00:00.000+0000",
          "premiumStreamingOnly": false,
          "trackNumber": 3,
          "volumeNumber": 1,
          "version": null,
          "popularity": 55,
          "copyright": "A Mercury Records Release; \u2117 2011 UMG Recordings, Inc.",
          "url": "http://www.tidal.com/track/14492425",
          "isrc": "USUM71119189",
          "editable": false,
          "explicit": true,
          "audioQuality": "LOSSLESS",
          "audioModes": [
            "STEREO"
          ],
          "mediaMetadata": {
            "tags": [
              "LOSSLESS"
            ]
          },
          "artist": {
            "id": 3665225,
            "name": "Neon Trees",
            "type": "MAIN",
            "picture": "e6f17398-759e-45a0-9673-6ded6811e199"
          },
          "artists": [
            {
              "id": 3665225,
              "name": "Neon Trees",
              "type": "MAIN",
              "picture": "e6f17398-759e-45a0-9673-6ded6811e199"
            }
          ],
          "album": {
            "id": 14492422,
            "title": "Picture Show",
            "cover": "1c2d7c90-034e-485a-be1f-24a669c7e6ee",
            "vibrantColor": "#f8af88",
            "videoCover": null
          },
          "mixes": {
            "TRACK_MIX": "0019768c833a193c29829e5bf473fc"
          }
        }

    </details>

  - If the clients are authenticated, you can create a user playlist and
    add tracks to it. Using the track IDs for "Everybody Talks" by Neon
    Trees from the previous example:

    **Private Qobuz API**

        >>> playlist_qobuz = client_qobuz.create_playlist(
        ...     "Minim",
        ...     description="A playlist created using Minim."
        ... )
        >>> client_qobuz.add_playlist_tracks(playlist_qobuz["id"], 5653620)

    **Spotify Web API**

        >>> playlist_spotify = client_spotify.create_playlist(
        ...     "Minim",
        ...     description="A playlist created using Minim."
        ... )
        >>> client_spotify.add_playlist_items(
        ...     playlist_spotify["id"],
        ...     ["spotify:track:2iUmqdfGZcHIhS3b9E9EWq"]
        ... )

    **Private TIDAL API**

        >>> playlist_tidal = client_tidal.create_playlist(
        ...     "Minim",
        ...     description="A playlist created using Minim."
        ... )
        >>> client_tidal.add_playlist_items(playlist_tidal["data"]["uuid"],
        ...                                 14492425)


pkgId: f6cbb7e7a91a9b2ff8b21d3e61d3efe7b997cb7ff456cd43485b0a5ec7c7fcbb
name: python-minimal-activitypub-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for minimal-activitypub
url: https://pypi.org/project/minimal-activitypub/
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-minimal-activitypub-1.3.1-1.src.rpm
location_href: Packages/python-minimal-activitypub-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  |Repo| |CI| |Downloads|
  |pip-audit| |CodeLimit|
  |Codestyle| |Version| |Wheel|
  |AGPL|
  Minimal-ActivityPub is a minimal Python implementation of the ActivityPub rest API used by `Mastodon`_, `Pleroma`_,
  and `Takahe`_. This implementation makes use of asyncio where appropriate. It is intended to be used as a library by
  other applications. No standalone functionality is provided.
  Minimal refers to the fact that only API calls I need for my other projects `Fedinesia`_, `Lemmy2Fedi`_ and
  `Tootbot`_ are implemented.
  **DO NOT** expect a full or complete implementation of all `ActivityPub API <https://activitypub.rocks/>`_ functionality.
  For more details have a look at the `Documentation`_


pkgId: 8175f789ab7e16fb47e09dc270242d774626c98c5340e472bfdd467168eed04b
name: python-miniobj-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for miniobj
url: https://pypi.org/project/miniobj/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-miniobj-0.0.2-1.src.rpm
location_href: Packages/python-miniobj-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Minimum wavefront .obj file parser in Python


  ```bash
  pip install miniobj
  ```


  ```python
  from miniobj import MiniObj

  obj_mesh = MiniObj("mesh.obj")

  obj_mesh.load(as_triangles=False)

  obj_mesh.export("output.obj")
  ```


  ```python
  obj_mesh.scale_unit() # scale min coord to 0, max coord to 1
  obj_mesh.quantize(bins=64) # quantize to 64x64x64
  obj_mesh.export("output.obj")
  ```

  Check out [main.py](main.py) for more examples.

rpm_license:
  MIT License  Copyright (c) 2024 Yongsen Mao  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: 19ab9d825b7c38938f688cb1bff3675528ace7d3c54931e9519e727ea9928e5e
name: python-miniogre-help
arch: noarch
version: 0.11.5
epoch: 0
release: 1
summary: Development documents and examples for miniogre
url: https://github.com/ogre-run/miniogre
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-miniogre-0.11.5-1.src.rpm
location_href: Packages/python-miniogre-help-0.11.5-1.noarch.rpm
checksum_type: sha256
description:
  **miniogre** is a command-line tool that helps developers automate the process of setting up reproducible Python environments. It leverages AI to analyze a Python codebase and automatically generate necessary files such as `Dockerfile`, `requirements.txt`, and SBOM (Software Bill of Materials) files.  This simplifies packaging Python applications and significantly reduces the time spent on dependency management.  It can even update your README file to accurately reflect the current state of your project.

  ![miniogre_gif_33](https://github.com/ogre-run/miniogre/assets/6482944/0850dbb5-6634-4f08-80a9-6fd8e3ca8e03)



  Managing software dependencies is a tedious and time-consuming task for developers. This is especially problematic in AI/ML development, where rapidly evolving Python packages often have poor documentation or outdated configuration files.  miniogre addresses this issue by using AI to automate the dependency setup process. This reduces the time spent "dependency hunting" from hours to minutes, allowing developers to focus on writing code instead of wrestling with environments.



  miniogre performs the following actions:

  1. **Identifies the primary code language:**  miniogre analyzes the project directory. Currently optimized for Python projects.
  2. **Reads the README file:** If a README exists, miniogre reads it to gather information about the project.
  3. **Crawls the source code:**  The code is analyzed to identify import statements and extract a preliminary list of dependencies.
  4. **Refines the requirements:**  miniogre leverages a Large Language Model (LLM) of your choice (OpenAI, Mistral, Groq, or OctoAI) to refine the dependency list and create a `requirements.txt` file.  The LLM helps to resolve complex dependencies and ensure compatibility.
      * Note: current implementation uses `uv pip compile` to lock requirements, removing the need for an LLM cleaning step for dependency generation.
  5. **Generates supporting files:** It generates a `Dockerfile` enabling containerization of your project and an SBOM (`sbom.json`) documenting all project dependencies.
  6. **Builds a Docker image (optional):**  miniogre can build a Docker image of the application, facilitating easy deployment and sharing.
  7. **Spins up a container (optional):**  miniogre can run the application in a Docker container.



  - **Python 3.10 or higher:**  miniogre is written in Python and requires this version. [Download Python](https://www.python.org/downloads/).
  - **Docker:**  Containerization platform for consistent environments. [Download Docker](https://docs.docker.com/get-docker/).
  - **pipx (recommended) or pip:** Python package installers.  pipx is recommended for isolated installations.  [Download pipx](https://pipxproject.github.io/pipx/installation/).  [Download pip](https://pip.pypa.io/en/stable/installing/).
  - **LLM API Key:** You need an API key for at least one of the following LLM providers:
      - **OpenAI:**  Set your API key using `export OPENAI_API_KEY=<YOUR_TOKEN>`.
      - **Mistral AI:** Set your API key using `export MISTRAL_API_KEY=<YOUR_TOKEN>`.
      - **Groq:** Set your API key using `export GROQ_SECRET_ACCESS_KEY=<YOUR_TOKEN>`.
      - **Ogre:** Set your token using `export OGRE_TOKEN=<YOUR_TOKEN>`.



  Miniogre can be installed using pipx or pip:

  - With pipx (recommended): `pipx install miniogre`
  - With pip: `pip install miniogre`

  You can also build from source using Poetry: `poetry build && pipx install dist/*.whl` (or `pip install dist/*.whl`).  A helper script, `install.sh`, is provided in the repository to simplify this process.




  1. **Navigate to Project Directory:** Open your terminal and go to the root directory of your Python project.

  2. **Run miniogre:** Use the following command to analyze your project and generate the reproducibility artifacts:

     ```bash
     miniogre run
     ```
  By default, it will generate the `Dockerfile`, `requirements.txt`, and `sbom.json` in an `ogre_dir` directory, build a Docker image named `miniogre/<your_project_name>:latest`, and then start a container. You can customize the LLM provider, baseimage, port mapping and more using command-line options. If you don't want to build a container, simply add the `--no-container` flag.



  - `run`: Executes the full miniogre pipeline, generating required files, building a Docker image, and optionally spinning up a container.
  - `readme`: Generates or updates the project's `README.md` file based on source code analysis.
  - `eval`: Evaluates the quality of the project's README file on a scale of 1-10.
  - `spinup`: Spins up a Docker container of the application if an image has already been built.
  - `version`: Displays the installed version of miniogre.
  - `build-ogre-image`: Builds a base Docker image with miniogre pre-installed (primarily for deployments to environments like Google Cloud Run).
  - `cloud`: Sends the project folder as a tarball to a terminal server in the cloud (e.g. `terminal.ogre.run`).
  - `ask`: Asks a question about the project or a code issue (still experimental).



  Contributions are welcome!  For inquiries, contact [contact@ogre.run](mailto:contact@ogre.run).


pkgId: ccb8d35b90d5b38167d83295672e2789d0f107a139026183e29c4518fb252cc2
name: python-ministats-help
arch: noarch
version: 0.3.12
epoch: 0
release: 1
summary: Development documents and examples for ministats
url: https://github.com/minireference/ministats
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ministats-0.3.12-1.src.rpm
location_href: Packages/python-ministats-help-0.3.12-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/ministats.svg)](https://pypi.python.org/pypi/ministats)
  [![Documentation Status](https://readthedocs.org/projects/ministats/badge/?version=latest)](https://ministats.readthedocs.io/en/latest/?version=latest)

  Common statistical testing procedures and plotting functions used for STATS 101.
  The code is intentionally simple to make it easy to read for beginners.

  -   Free software: MIT license
  -   Documentation: https://ministats.readthedocs.io




  This library contains helper functions for statistical analysis procedures implemented "from scratch."
  Many of these procedures can be performed more quickly by simply calling an appropriate function defined in one of the existing libraries for statistical analysis,
  but we deliberately show the step by step procedures,
  so you'll know what's going on under the hood.





  - Simple, concise code.
  - Uses standard prob. libraries `scipy.stats`.
  - Tested against other statistical software.





  - [x] import plot helpers from https://github.com/minireference/noBSstatsnotebooks/ repo
  - [x] import stats helpers from https://github.com/minireference/noBSstatsnotebooks/ repo
  - [x] add GitHub actions CI
  - [x] add some tests
  - [x] Move `plots.py` into `plots/__init__.py`:
  - [ ] Distribute functions `plots/__init__.py` into submodules:
     - [x] `plots/probability.py`: functions for visualizing probability distributions
     - [x] `plots/regression.py`: linear model visualization functions
     - [x] `plots/figures.py`: special code used for figures in the book (not included in the main namespace)
     - [ ] remove `plots/figures` plotting functions from `ministats` namespace
  - [ ] add more tests
    - [ ] one-sample equivalence test
    - [ ] two-sample equivalence test






  - Imported plotting functions from `plot_helpers.py` (in main namespace for now)



  - First release on PyPI.


pkgId: c1e2dd6a417810a1d67c66ee5e405ebf49dbccb9e59aced3c6644548c86ff876
name: python-mintii-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for mintii
url: https://mintii.ai
rpm_license: Proprietary - All Rights Reserved
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mintii-0.1.1-1.src.rpm
location_href: Packages/python-mintii-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  The intelligent LLM model selection and optimization library by [Mintii Labs](https://mintii.ai).



  Mintii Router is a sophisticated AI model selection system that automatically chooses the best Large Language Model (LLM) for each specific prompt, optimizing for both cost and quality. Our system evaluates over 20 different LLMs in real-time to ensure you get the best possible response while minimizing costs.



  - 🎯 **Intelligent Model Selection**: Automatically selects the most suitable LLM for each prompt
  - 💰 **Cost Optimization**: Achieve up to 80% cost reduction through smart model routing
  - 🚀 **Quality Assurance**: Maintains high-quality responses through sophisticated model evaluation
  - 🔄 **Adaptive Learning**: Continuously improves selection criteria based on performance data
  - 📊 **Usage Analytics**: Track and optimize your LLM usage patterns



  ```bash
  pip install mintii-router
  ```



  ```python
  from mintii import Router
  from dotenv import load_dotenv
  import os


  load_dotenv()


  router = Router(api_key=os.getenv('MINTII_API_KEY'))


  response = router.generate("Explain quantum computing in simple terms")
  print(response.content)
  ```



  - **Smart Model Selection**: Automatically chooses the best model based on:
    - Prompt complexity
    - Required capabilities
    - Cost constraints
    - Performance requirements

  - **Cost Optimization**: Reduces costs by:
    - Selecting cost-effective models
    - Optimizing token usage
    - Balancing quality and cost

  - **Quality Assurance**: Maintains high standards through:
    - Model capability matching
    - Response quality monitoring
    - Consistent performance tracking



  For full documentation, visit [docs.mintii.ai](https://docs.mintii.ai)



  - Email: support@mintiilabs.com
  - Documentation: [docs.mintii.ai](https://docs.mintii.ai)
  - Issues: [GitHub Issues](https://github.com/mintiilabs/mintii-router/issues)



  Proprietary. Copyright © 2024 Mintii Labs. All rights reserved.


pkgId: 365f849426f2b04a94d4fee1df337534f5f349925a4b4e3335d393b635d5c702
name: python-mirascope-help
arch: noarch
version: 1.13.0
epoch: 0
release: 1
summary: Development documents and examples for mirascope
url: https://mirascope.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mirascope-1.13.0-1.src.rpm
location_href: Packages/python-mirascope-help-1.13.0-1.noarch.rpm
checksum_type: sha256
description:
  Mirascope is a powerful, flexible, and user-friendly library that simplifies the process of working with LLMs through a unified interface that works across various supported providers, including [OpenAI](https://openai.com/), [Anthropic](https://www.anthropic.com/), [Mistral](https://mistral.ai/), [Gemini](https://gemini.google.com), [Groq](https://groq.com/), [Cohere](https://cohere.com/), [LiteLLM](https://www.litellm.ai/), [Azure AI](https://azure.microsoft.com/en-us/solutions/ai), [Vertex AI](https://cloud.google.com/vertex-ai), and [Bedrock](https://aws.amazon.com/bedrock/).
  Whether you're generating text, extracting structured information, or developing complex AI-driven agent systems, Mirascope provides the tools you need to streamline your development process and create powerful, robust applications.

  Install Mirascope, specifying the provider(s) you intend to use, and set your API key:
  ```bash
  pip install "mirascope[openai]"
  export OPENAI_API_KEY=XXXXX
  ```
  Make your first call to an LLM to extract the title and author of a book from unstructured text:
  ```python
  from mirascope.core import openai
  from pydantic import BaseModel
  class Book(BaseModel):
      title: str
      author: str
  @openai.call("gpt-4o-mini", response_model=Book)
  def extract_book(text: str) -> str:
      return f"Extract {text}"
  book = extract_book("The Name of the Wind by Patrick Rothfuss")
  assert isinstance(book, Book)
  print(book)

  ```

  Check out our [quickstart tutorial](https://mirascope.com/tutorials/getting_started/quickstart) and many other tutorials for an interactive way to getting started with Mirascope.

  For a complete guide on how to use all of the various features Mirascope has to offer, read through our [Learn](https://mirascope.com/learn) documentation.

  Mirascope uses [Semantic Versioning](https://semver.org/).

  This project is licensed under the terms of the [MIT License](https://github.com/Mirascope/mirascope/blob/dev/LICENSE).

rpm_license:
  MIT License  Copyright (c) 2023 Mirascope, Inc.  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: aba36f693e63be4ba91534dd26f2799772b743430050bbb35e01dcf26bac0edc
name: python-misp-lib-stix2-help
arch: noarch
version: 3.0.1.2
epoch: 0
release: 1
summary: Development documents and examples for misp-lib-stix2
url: https://oasis-open.github.io/cti-documentation/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-misp-lib-stix2-3.0.1.2-1.src.rpm
location_href: Packages/python-misp-lib-stix2-help-3.0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  This is the MISP core team STIX2 library forked from the `OASIS TC Open Repository <https://www.oasis-open.org/resources/open-repositories/>`__.
  This repository provides Python APIs for serializing and de-serializing STIX2
  JSON content, along with higher-level APIs for common tasks, including data
  markings, versioning, and for resolving STIX IDs across multiple data sources.
  For more information, see `the documentation <https://stix2.readthedocs.io/>`__ on ReadTheDocs.


pkgId: f8bec3d4162e983691dae5046209ba24f2ef292cff0a252dab2781f29f318199
name: python-missim-cli-help
arch: noarch
version: 1.18.0
epoch: 0
release: 1
summary: Development documents and examples for missim-cli
url: https://github.com/Greenroom-Robotics/missim
rpm_license: Copyright (C) 2023, Greenroom Robotics
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-missim-cli-1.18.0-1.src.rpm
location_href: Packages/python-missim-cli-help-1.18.0-1.noarch.rpm
checksum_type: sha256
description:
  ![MISSIM CLI](./docs/missim_cli.png)

  Publicly available on [PyPi](https://pypi.org/project/missim-cli/) for convenience but if you don't work at Greenroom Robotics, you probably don't want to use this.



  * For development:
    * `pip install -e ./packages/missim_config`
    * `pip install -e ./tools/missim_cli`
  * For production: `pip install missim-cli`
  * You may also need to `export PATH=$PATH:~/.local/bin` if you don't have `~/.local/bin` in your path
  * Install autocomplete:
    * bash: `echo 'eval "$(_MISSIM_COMPLETE=bash_source missim)"' >> ~/.bashrc`
    * zsh: `echo 'eval "$(_MISSIM_COMPLETE=zsh_source missim)"' >> ~/.zshrc` (this is much nicer)
    * If using zsh, the git checker plugin make terminal slow. Suggest you run `git config oh-my-zsh.hide-info 1` in the zsh terminal inside the repo



  * `missim --help` to get help with the CLI



  MISSIM CLI can be ran in dev mode. This will happen if it is installed with `pip install -e ./tools/missim` or if the environment variable `MISSIM_CLI_DEV_MODE` is set to `true`.


pkgId: 4872c265f91796d00b33297f32a99b29eda360d39e14fc22462c6ae4ecfe9f4c
name: python-missim-config-help
arch: noarch
version: 1.18.0
epoch: 0
release: 1
summary: Development documents and examples for missim-config
url: https://github.com/Greenroom-Robotics/missim
rpm_license: Copyright (C) 2023, Greenroom Robotics
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-missim-config-1.18.0-1.src.rpm
location_href: Packages/python-missim-config-help-1.18.0-1.noarch.rpm
checksum_type: sha256
description:
  Missim Config is used to load config stored inside the `~/.config/greenroom` folder.



  * `pip install -e ./packages/missim_config`





  ```python
  from missim_config import read

  config = read()
  ```



  ```python
  from missim_config import write, MissimConfig

  config = MissimConfig()

  write(config)

  ```



  After changing the dataclasses, you can generate the schemas with:

  ```bash
  python3 -m missim_config.generate_schemas
  ```


pkgId: 6dcb35c1436c8b303ed5da499bd687c2d4651b0a6d2070e2743e30e5f11265b9
name: python-mistral-vectordb-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mistral-vectordb
url: https://github.com/veerakrish/mistral-vectordb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mistral-vectordb-1.0.0-1.src.rpm
location_href: Packages/python-mistral-vectordb-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  /api/collections/add       | 100/minute
  /api/collections/query     | 200/minute
  /api/collections/get       | 50/minute
  /api/collections/delete    | 20/minute
  /api/generate_key          | 5/minute
  /api/batch/submit          | 10/minute
  /health                    | 60/minute
  /system                    | 10/minute
  ```


  ```python

  response = requests.post(
      f"{API_URL}/api/generate_key",
      json={"name": "client1", "expiry_days": 30}
  )
  api_key = response.json()["api_key"]
  ```

  ```python

  auth_url = f"{API_URL}/login/github"


  ```

  ```python

  response = requests.get(
      f"{API_URL}/system",
      auth=("admin", "admin_password")
  )
  ```

  1. **API Keys**:
     - Store securely in environment variables
     - Rotate regularly
     - Set appropriate expiration
  2. **Sensitive Data**:
     - Always use HTTPS in production
     - Encrypt metadata
     - Use secure storage
  3. **Monitoring**:
     - Watch rate limit violations
     - Monitor error rates
     - Track system metrics

  1. **Environment Setup**:
  ```bash

  export MISTRAL_API_KEY="your-key"
  export GITHUB_CLIENT_ID="your-id"
  export GITHUB_CLIENT_SECRET="your-secret"
  ```
  2. **Prometheus Monitoring**:
  ```yaml

  scrape_configs:
    - job_name: 'vectordb'
      static_configs:
        - targets: ['localhost:8000']
  ```
  3. **Secure Server Start**:
  ```python
  start_server(
      host="0.0.0.0",
      port=443,
      ssl_keyfile="path/to/key.pem",
      ssl_certfile="path/to/cert.pem"
  )
  ```

  Contributions are welcome! Please read our [Contributing Guidelines](CONTRIBUTING.md) for details.

  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


  ```python
  from mistral_vectordb import Collection
  from mistral_vectordb.security import SecureStorage, HIPAA_Compliance
  class MedicalRecordSystem:
      def __init__(self):
          self.secure = SecureStorage(mistral_api_key)
          self.hipaa = HIPAA_Compliance()
          self.collection = Collection(
              name="medical_records",
              embedding_function=MistralEmbedding().embed
          )
      def add_patient_record(self, record):
          
          if not self.hipaa.validate_record(record):
              raise ValueError("Record does not meet HIPAA requirements")
          
          encrypted_phi = self.secure.encrypt_data({
              "patient_id": record["patient_id"],
              "ssn": record["ssn"],
              "dob": record["dob"]
          })
          
          self.collection.add(
              documents=[record["medical_history"]],
              metadatas=[{
                  "phi": encrypted_phi,
                  "department": record["department"],
                  "access_level": "medical_staff"
              }]
          )
      def search_records(self, query, staff_credentials):
          if not self.hipaa.verify_access(staff_credentials):
              raise PermissionError("Unauthorized access")
          return self.collection.query(
              query_texts=[query],
              where={"access_level": staff_credentials["level"]}
          )
  ```

  ```python
  from mistral_vectordb.server import start_server
  import asyncio
  from watchdog.observers import Observer
  from watchdog.events import FileSystemEventHandler
  class DocumentHandler(FileSystemEventHandler):
      def __init__(self, api_url, api_key):
          self.api_url = api_url
          self.api_key = api_key
          self.headers = {
              "Authorization": f"Bearer {api_key}",
              "Content-Type": "application/json"
          }
      def on_created(self, event):
          if event.is_directory:
              return
          
          asyncio.create_task(self.process_document(event.src_path))
      async def process_document(self, filepath):
          
          response = requests.post(
              f"{self.api_url}/api/batch/submit",
              headers=self.headers,
              json={
                  "collection_name": "realtime_docs",
                  "documents": [{"filepath": filepath}]
              }
          )
          
          job_id = response.json()["job_id"]
          while True:
              status = requests.get(
                  f"{self.api_url}/api/batch/{job_id}/status",
                  headers=self.headers
              ).json()
              if status["status"] in ["completed", "failed"]:
                  break
              await asyncio.sleep(1)

  observer = Observer()
  observer.schedule(
      DocumentHandler(API_URL, API_KEY),
      path="watched_directory",
      recursive=False
  )
  observer.start()
  ```

  ```python
  from mistral_vectordb import Collection
  from PIL import Image
  import pytesseract
  from transformers import CLIPProcessor, CLIPModel
  class MultiModalSearch:
      def __init__(self):
          self.collection = Collection("multimodal")
          self.clip = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
          self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
      def process_image(self, image_path):
          
          image = Image.open(image_path)
          text = pytesseract.image_to_string(image)
          
          inputs = self.processor(images=image, return_tensors="pt")
          image_features = self.clip.get_image_features(**inputs)
          return {
              "text": text,
              "image_embedding": image_features.tolist()[0],
              "metadata": {
                  "type": "image",
                  "path": image_path
              }
          }
      def add_image(self, image_path):
          processed = self.process_image(image_path)
          self.collection.add(
              documents=[processed["text"]],
              metadatas=[processed["metadata"]],
              embeddings=[processed["image_embedding"]]
          )
      def search(self, query, mode="text"):
          if mode == "text":
              return self.collection.query(
                  query_texts=[query]
              )
          elif mode == "image":
              
              processed = self.process_image(query)
              return self.collection.query(
                  query_embeddings=[processed["image_embedding"]]
              )
  ```


  ```python
  import requests
  import os
  base_url = "http://localhost:8000"
  headers = {
      "Authorization": f"Bearer {os.getenv('MISTRAL_API_KEY')}",
      "Content-Type": "application/json"
  }

  response = requests.post(
      f"{base_url}/vectors/batch_add",
      headers=headers,
      json={
          "documents": [
              "First document",
              "Second document",
              "Third document"
          ],
          "metadata": [
              {"category": "A", "tags": ["tag1"]},
              {"category": "B", "tags": ["tag2"]},
              {"category": "C", "tags": ["tag3"]}
          ]
      }
  )

  response = requests.delete(
      f"{base_url}/vectors/delete",
      headers=headers,
      json={
          "ids": ["vec_1", "vec_2"]
      }
  )

  response = requests.put(
      f"{base_url}/vectors/update",
      headers=headers,
      json={
          "id": "vec_1",
          "metadata": {"category": "updated", "tags": ["new_tag"]}
      }
  )

  response = requests.post(
      f"{base_url}/vectors/search",
      headers=headers,
      json={
          "query_text": "example query",
          "n_results": 5,
          "filters": {
              "category": "A",
              "tags": {"$in": ["tag1", "tag2"]},
              "date": {"$gt": "2024-01-01"}
          },
          "include_metadata": True,
          "include_distances": True
      }
  )

  response = requests.post(
      f"{base_url}/vectors/hybrid_search",
      headers=headers,
      json={
          "query_text": "example query",
          "keyword_weight": 0.3,
          "semantic_weight": 0.7,
          "n_results": 5
      }
  )
  ```

  ```python

  response = requests.post(
      f"{base_url}/collections/create",
      headers=headers,
      json={
          "name": "my_collection",
          "dimension": 768,
          "metric": "cosine"
      }
  )

  response = requests.get(
      f"{base_url}/collections/list",
      headers=headers
  )

  response = requests.get(
      f"{base_url}/collections/my_collection/stats",
      headers=headers
  )

  response = requests.delete(
      f"{base_url}/collections/my_collection",
      headers=headers
  )
  ```

  ```python

  response = requests.get(
      f"{base_url}/admin/stats",
      headers=headers
  )

  response = requests.get(
      f"{base_url}/admin/audit_logs",
      headers=headers,
      params={
          "start_time": "2024-01-01T00:00:00Z",
          "end_time": "2024-12-31T23:59:59Z",
          "severity": "ERROR",
          "limit": 100
      }
  )

  response = requests.put(
      f"{base_url}/admin/rate_limits",
      headers=headers,
      json={
          "default_rate": 200,
          "ip_whitelist": ["192.168.1.100"]
      }
  )
  ```


  1. **Connection Refused**
  ```
  ConnectionRefusedError: [Errno 61] Connection refused
  ```
  - Check if the server is running
  - Verify the correct host and port
  - Ensure no firewall is blocking the connection
  - Try using `localhost` instead of `0.0.0.0`
  2. **Authentication Errors**
  ```
  {"error": "Invalid API key"}
  ```
  - Verify API key is set correctly in environment
  - Check if API key has expired
  - Ensure Authorization header is formatted correctly
  - Try regenerating the API key
  3. **Rate Limiting Issues**
  ```
  {"error": "Rate limit exceeded"}
  ```
  - Check current rate limit configuration
  - Consider using batch operations
  - Implement exponential backoff
  - Request rate limit increase if needed
  4. **Memory Issues**
  ```
  MemoryError: Unable to allocate array
  ```
  - Reduce batch size for vector operations
  - Monitor server memory usage
  - Consider upgrading server resources
  - Enable memory optimization settings
  5. **Index Corruption**
  ```
  {"error": "Index corrupted"}
  ```
  - Backup data immediately
  - Check disk space
  - Rebuild index from backup
  - Enable periodic index verification

  1. **Enable Debug Logging**
  ```python
  import logging
  logging.basicConfig(level=logging.DEBUG)
  logger = logging.getLogger('mistral_vectordb')
  ```
  2. **Check Server Logs**
  ```bash

  tail -f ./vectordb_data/logs/server.log

  grep "ERROR" ./vectordb_data/logs/server.log
  ```
  3. **Verify Configuration**
  ```python

  response = requests.get(
      f"{base_url}/admin/config",
      headers=headers
  )
  print(response.json())
  ```


  ```yaml

  server:
    host: 0.0.0.0
    port: 8000
    workers: 8
    ssl_enabled: true
    ssl_cert: /path/to/cert.pem
    ssl_key: /path/to/key.pem
    max_request_size: 10MB
  storage:
    directory: /data/vectordb
    backup_enabled: true
    backup_interval: 24h
    backup_retention: 7d
  security:
    rate_limit:
      default_rate: 1000
      burst_rate: 2000
    audit:
      enabled: true
      log_dir: /var/log/vectordb
      rotation_size: 100MB
      retention_days: 90
    encryption:
      enabled: true
      key_rotation: 30d
  ```

  ```dockerfile

  FROM python:3.9-slim
  WORKDIR /app
  COPY requirements.txt .
  RUN pip install --no-cache-dir -r requirements.txt
  COPY . .

  RUN useradd -m vectordb
  USER vectordb
  CMD ["vectordb-server", "--config", "production_config.yaml"]
  ```
  ```yaml

  version: '3.8'
  services:
    vectordb:
      build: .
      ports:
        - "8000:8000"
      volumes:
        - vectordb_data:/data/vectordb
        - vectordb_logs:/var/log/vectordb
      environment:
        - MISTRAL_API_KEY=${MISTRAL_API_KEY}
      deploy:
        resources:
          limits:
            memory: 8G
          reservations:
            memory: 4G
  ```

  1. **Memory Management**
  - Use memory-mapped files for large indices
  - Implement periodic garbage collection
  - Monitor memory usage with Prometheus/Grafana
  2. **CPU Optimization**
  - Enable multi-threading for search operations
  - Use batch processing for large updates
  - Configure optimal number of workers
  3. **Disk I/O**
  - Use SSD storage for better performance
  - Implement proper backup strategy
  - Monitor disk usage and IOPS

  1. **Network Security**
  - Use reverse proxy (nginx/traefik)
  - Enable SSL/TLS
  - Implement IP whitelisting
  - Use secure headers
  2. **Access Control**
  - Implement role-based access
  - Regular key rotation
  - Audit logging
  - Rate limiting
  3. **Data Protection**
  - Regular backups
  - Data encryption at rest
  - Secure key management
  - Compliance monitoring

  ```python

  response = requests.get(
      f"{base_url}/metrics",
      headers=headers
  )

  response = requests.get(
      f"{base_url}/health/detailed",
      headers=headers
  )
  ```

  ```bash


  backup_dir="/backup/vectordb"
  date=$(date +%Y%m%d)

  curl -X POST http://localhost:8000/admin/maintenance/start

  tar -czf "$backup_dir/vectordb_$date.tar.gz" /data/vectordb/

  curl -X POST http://localhost:8000/admin/maintenance/end

  find "$backup_dir" -type f -mtime +7 -delete


pkgId: 5523efad28a5121cbf1426af2b7f18758b50523cf618282a94e4fb28800faf29
name: python-mistralvdb-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mistralvdb
url: https://github.com/veerakrish/mistralvdb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mistralvdb-0.1.0-1.src.rpm
location_href: Packages/python-mistralvdb-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A vector database optimized for Mistral AI embeddings with HNSW indexing. Features include:
  - Efficient similarity search using HNSW indexing
  - Vector compression for reduced memory usage
  - Built-in REST API server
  - Secure authentication
  - Multiple collection support
  - Automatic persistence



  ```bash
  pip install mistralvdb
  ```





  ```python
  from mistralvdb import MistralVDB


  db = MistralVDB(
      api_key="your-mistral-api-key",
      collection_name="my_collection"
  )


  texts = [
      "The quick brown fox jumps over the lazy dog",
      "Python is a versatile programming language"
  ]
  metadata = [
      {"type": "example"},
      {"type": "programming"}
  ]
  ids = db.add_texts(texts, metadata=metadata)


  results = db.search("programming language", k=4)
  for doc_id, score in results:
      print(f"Score: {score}")
      print(f"Text: {db.get_text(doc_id)}")
      print(f"Metadata: {db.get_metadata(doc_id)}\n")
  ```



  1. Start the server:
  ```bash

  export MISTRAL_API_KEY=your-mistral-api-key


  mistralvdb-server --host 127.0.0.1 --port 8000
  ```

  2. Use the client:
  ```python
  from mistralvdb.client import MistralVDBClient


  client = MistralVDBClient()


  client.login(username="admin", password="admin-password")


  docs = ["Document 1", "Document 2"]
  client.add_documents(docs, collection_name="my_collection")


  results = client.search("my query", collection_name="my_collection")
  ```




  - Efficient approximate nearest neighbor search
  - Configurable index parameters (M, ef_construction, ef)
  - Thread-safe operations


  - Product Quantization for reduced memory usage
  - Configurable compression parameters
  - Minimal accuracy loss


  - RESTful API with FastAPI
  - JWT authentication
  - Collection management
  - Swagger UI documentation


  - Automatic persistence
  - Multiple collections
  - Custom storage location
  - Collection metadata




  - `MISTRAL_API_KEY`: Your Mistral AI API key (required)


  ```bash
  mistralvdb-server --help
  ```



  1. Clone the repository:
  ```bash
  git clone https://github.com/yourusername/mistralvdb.git
  cd mistralvdb
  ```

  2. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```

  3. Run tests:
  ```bash
  pytest tests/
  ```



  MIT License - see LICENSE file for details.



  Contributions are welcome! Please feel free to submit a Pull Request.


pkgId: b507f7b9090da35be6347703191cf24eacfdf0e9fe3135a57dcb016814bab30b
name: python-mitene-download-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for mitene-download
url: https://pypi.org/project/mitene-download/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mitene-download-0.4.0-1.src.rpm
location_href: Packages/python-mitene-download-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Download medias from https://mitene.us/ or https://family-album.com/ to keep a local backup.



  Install with `pip install mitene_download`.

  From mitene app, invite a family member for the web version and copy the URL ( that should be something like `https://mitene.us/f/abcd123456` )

  Run the script with `mitene_download https://mitene.us/f/abcd123456`, using the URL from previous step.

  This will download all photos and video in `out` folder. Some text files will be created with the comments.

  If the album is password-protected, you can specify the password using `--password` command line argument, similar to this: `mitene_download https://mitene.us/f/abcd123456 --password the_password`.


pkgId: 3c09718989647189ef83b7f2e1192ca63499a6c4bbd6ae7f709676919cc48eed
name: python-mk1pass-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for mk1pass
description: Generate random strings for passwords.
url: https://miketurkey.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mk1pass-0.0.5-1.src.rpm
location_href: Packages/python-mk1pass-help-0.0.5-1.noarch.rpm
checksum_type: sha256
rpm_license:
  ###################################################################### ####################  SOFTWARE LICENSE   ############################# ######################################################################  mk1pass, Generate random strings for passwords. Copyright (C) 2023-2024 Mike Turkey (real name: Takaaki Watanabe) contact: voice[ATmark]miketurkey.com license: GPLv3 License  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  ADDITIONAL MACHINE LEARNING PROHIBITION CLAUSE  In addition to the rights granted under the applicable license(GPL-3), you are expressly prohibited from using any form of machine learning, artificial intelligence, or similar technologies to analyze, process, or extract information from this software, or to create derivative works based on this software.  This prohibition includes, but is not limited to, training machine learning models, neural networks, or any other automated systems using the code or output of this software.  The purpose of this prohibition is to protect the integrity and intended use of this software. If you wish to use this software for machine learning or similar purposes, you must seek explicit written permission from the copyright holder.  see also GPL-3 Licence: https://www.gnu.org/licenses/gpl-3.0.html.en Mike Turkey.com: https://miketurkey.com/  ###################################################################### ####################  DOCUMENT LICENSE   ############################# ######################################################################  Copyright 2023 Mike Turkey (real name: Takaaki Watanabe) contact: voice[ATmark]miketurkey.com license: GFDL1.3 License  Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".  ADDITIONAL MACHINE LEARNING PROHIBITION CLAUSE  In addition to the rights granted under the GNU Free Documentation License, Version 1.3, you are expressly prohibited from using any form of machine learning, artificial intelligence, or similar technologies to analyze, process, or extract information from this document, or to create derivative works based on this document.  This prohibition includes, but is not limited to, training machine learning models, neural networks, or any other automated systems using the content of this document.  The purpose of this prohibition is to protect the integrity and intended use of this document. If you wish to use this document for machine learning or similar purposes, you must seek explicit written permission from the copyright holder.  Additional Term: Documentation  "Documentation" refers to any written or electronic materials, including but not limited to manuals, guides, help files, and any other accompanying explanatory materials, that are provided or made available along with the software. The Documentation may be in printed or digital format and is an integral part of the software package.  The Documentation is licensed under the terms of the GNU Free Documentation License (GFDL) version 1.3, a copy of which can be found at [https://www.gnu.org/licenses/fdl-1.3.txt]. Users are granted the right to copy, distribute, and/or modify the Documentation under the terms of the GFDL, but not to modify it in any way that would cause the Documentation to become subject to any license other than the GFDL.  Users are expressly prohibited from sublicensing or otherwise transferring their rights to the Documentation. Any reproduction, distribution, or modification of the Documentation must retain the notices and disclaimers of the GFDL.  This Additional Term forms an integral part of the overall software document license and should be interpreted in conjunction with the main terms and conditions outlined in the license agreement.  See also: GFDL1.3: https://www.gnu.org/licenses/fdl-1.3.txt Mike Turkey: https://miketurkey.com/


pkgId: 56290f466acf413971c8a57d237fcf2f96e368ec2b70dc64b500171662dd19a7
name: python-mkdocs-d2-plugin-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for mkdocs-d2-plugin
url: https://github.com/landmaj/mkdocs-d2-plugin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkdocs-d2-plugin-1.6.0-1.src.rpm
location_href: Packages/python-mkdocs-d2-plugin-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  A plugin for embedding D2 diagrams in MkDocs.

  **Documentation and live demo can be found
  [here](https://landmaj.github.io/mkdocs-d2-plugin/).**



  * [Python](https://www.python.org/) >= 3.9
  * [MkDocs](https://www.mkdocs.org/) >= 1.6.0
  * [D2](https://d2lang.com) >= 0.6.3



  Install the plugin using pip:

  ```bash
  pip install mkdocs-d2-plugin
  ```

  And add it to your `mkdocs.yml`:

  ```yaml
  plugins:
    - d2
  ```





  ````md
  ```d2
  shape: sequence_diagram
  Alice -> John: Hello John, how are you?
  Alice -> John.ack: John, can you hear me?
  John.ack -> Alice: Hi Alice, I can hear you!
  John -> Alice: I feel great!
  ```
  ````



  ```md
  ![Diagram](diagram.d2)
  ```



  You can find demo app in the `docs` directory.
  Live version is available [here](https://landmaj.github.io/mkdocs-d2-plugin/).

  To run in locally:

  ```bash
  cd docs
  python3 -m venv .venv
  source .venv/bin/activate
  pip install mkdocs-material mkdocs-d2-plugin
  mkdocs serve
  ```

  To run it using Docker:

  ```bash
  cd docs
  docker build --tag mkdocs-d2-plugin:latest .
  docker run --rm -it -p 8000:8000 -v ${PWD}:/docs mkdocs-d2-plugin:latest
  ```


pkgId: 521e473048dce16fcb34b821c04a970c696013063a7b3463dd254e5c45de13bc
name: python-mkdocs-drawio-converter-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mkdocs-drawio-converter
url: https://github.com/rajneesh-ril/mkdocs-drawio-converter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkdocs-drawio-converter-1.0.0-1.src.rpm
location_href: Packages/python-mkdocs-drawio-converter-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A MkDocs plugin that automatically converts Drawio (.drawio) files to SVG format during the build process.



  ```bash
  pip install mkdocs-drawio-converter
  ```



  - Draw.io desktop app installed (for the CLI tool)
  - MkDocs



  Add the following to your `mkdocs.yml`:

  ```yaml
  plugins:
    - drawio-converter:
        drawio_executable: /path/to/drawio  # Path to drawio executable
        source_dir: docs                    # Directory containing .drawio files
        output_dir: svg                     # Directory for output SVG files
  ```



  1. Place your .drawio files in your docs directory
  2. Build your MkDocs site
  3. Reference the converted SVG files in your markdown:

  ```markdown
  ![My Diagram](svg/diagram.svg)
  ```


pkgId: ba3d926131bc22ca2f3ffd4f56f77523d2b1211e5bc6589d826826106a58f2fe
name: python-mkdocs-macros-adr-summary-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for mkdocs-macros-adr-summary
url: https://febus982.github.io/mkdocs-macros-adr-summary
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkdocs-macros-adr-summary-1.1.0-1.src.rpm
location_href: Packages/python-mkdocs-macros-adr-summary-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Static Badge](https://img.shields.io/badge/Python-3.9_%7C_3.10_%7C_3.11_%7C_3.12_%7C_3.13-blue?logo=python&logoColor=white)
  [![Stable Version](https://img.shields.io/pypi/v/mkdocs-macros-adr-summary?color=blue)](https://pypi.org/project/mkdocs-macros-adr-summary/)
  [![stability-beta](https://img.shields.io/badge/stability-beta-33bbff.svg)](https://github.com/mkenney/software-guides/blob/master/STABILITY-BADGES.md#beta)

  [![Python tests](https://github.com/febus982/mkdocs-macros-adr-summary/actions/workflows/python-tests.yml/badge.svg?branch=main)](https://github.com/febus982/mkdocs-macros-adr-summary/actions/workflows/python-tests.yml)
  [![Maintainability](https://api.codeclimate.com/v1/badges/5631f62f6dcd3a34d7ae/maintainability)](https://codeclimate.com/github/febus982/mkdocs-macros-adr-summary/maintainability)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/5631f62f6dcd3a34d7ae/test_coverage)](https://codeclimate.com/github/febus982/mkdocs-macros-adr-summary/test_coverage)

  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)

  This is a macro plugin to generates summaries from a list of a ADR documents in a directory.

  The single ADR documents file names have to respect this format: `0000-my-decision-title.md`

  * start with 4 digits followed by the character `-`
  * the rest of the file name can contain only letters, numbers, dashes and underscores (`[A-Za-z0-9_-]` regex)
  * end with the `.md` extension

  Examples and documentation can be found [here](https://febus982.github.io/mkdocs-macros-adr-summary)

  The package should be stable enough for daily use. I'll release 1.0.0, and switch to semantic version,
  as soon as support for MADR version 2 has been implemented. Until that breaking changes can be introduced
  and will be documented in the GitHub release description.



  Enable the plugin in `mkdocs.yml`

  ```yaml
  plugins:
    - macros:
        modules:
          - mkdocs_macros_adr_summary
  ```

  Create a markdown page in your mkdocs website and use the `adr_summary` macro providing
  the path containing your ADR files relative to the `mkdocs.yml` file.

  ```markdown
  {{ adr_summary(adr_path="docs/adr", adr_style="nygard") }}
  ```

  `adr_style` can be `nygard` or `MADR3`



  The page output is generated using a jinja template, but you can provide a custom one. The file path
  must still be relative to the `mkdocs.yml` file.

  ```markdown
  {{ adr_summary(adr_path="docs/adr", adr_style="MADR3",m) }}
  ```

  The default template is:

  ```markdown
  | ID | Date | Decision | Status |
  |----|------|----------|--------|
  {% for d in documents %}| {{ d.document_id }} | {{ d.date.strftime('%d-%m-%Y') if d.date else "-"}} | [{{ d.title }}]({{ d.file_path }}) | {{ d.status }}  |
  {% endfor %}
  ```

  The `documents` variable in the jinja template is a Sequence of `ADRDocument` models:

  ```python
  @dataclass
  class ADRDocument:
      file_path: str
      document_id: Optional[int] = None
      title: Optional[str] = None
      date: Optional[date] = None
      status: Optional[str] = None
      statuses: Sequence[str] = tuple()
      deciders: Optional[str] = None
      consulted: Optional[str] = None
      informed: Optional[str] = None
  ```

  There are some differences in what metadata is available when using different formats:

  |           | Nygard | MADR3 | MADR2 |
  |-----------|--------|-------|-------|
  | file_path | ✅︎     | ✅︎    | ✅︎    |
  | title     | ✅︎     | ✅︎    | ✅︎    |
  | date      | ✅︎     | ✅︎    | ✅︎    |
  | status    | ⚠      | ✅︎    | ✅︎    |
  | statuses  | ✅︎     | ⚠     | ⚠     |
  | deciders  | ❌      | ✅︎    | ✅︎    |
  | consulted | ❌      | ✅︎    | ❌     |
  | informed  | ❌      | ✅︎    | ❌     |

  * **Nygard format**
      * `status` is the last item `statuses`. (I don't believe we should use multiple
        statuses, however `adr-tools` allows it)
      * `deciders`, `consulted` and `informed` are not supported by the format
  * **MADR2** and **MADR3**
      * I wasn't able to find an automated tool supporting superseding documents.
        By looking at the template it looks like there's a single status.
        `statuses` will return a list with a single status.



  The supported ADR formats are:
  * `nygard` format, it is recommended to use [adr-tools](https://github.com/npryce/adr-tools) to manage the directory
  * `MADR` [version 3](https://github.com/adr/madr/blob/3.0.0/template/adr-template.md)
  * `MADR` [version 2](https://github.com/adr/madr/blob/2.1.2/template/template.md)



  All the common commands used during development can be run using make targets:

  * `make dev-dependencies`: Install dev requirements
  * `make update-dependencies`: Update dev requirements
  * `make test`: Run test suite
  * `make check`: Run tests, code style and lint checks
  * `make fix`: Run code style and lint automatic fixes (where possible)
  * `make docs`: Render the mkdocs website locally


pkgId: c72f525be350379e7759bfd72b070bee6851a95ab940ba87041c9eeb67574e8f
name: python-mkdocs-monoweb-theme-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mkdocs-monoweb-theme
url: https://pypi.org/project/mkdocs-monoweb-theme/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkdocs-monoweb-theme-1.0.0-1.src.rpm
location_href: Packages/python-mkdocs-monoweb-theme-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a theme for MkDocs that is based on the [MonoWeb](https://owickstrom.github.io/the-monospace-web/) theme by Ola Wickström.


pkgId: 52911d04d798aaaa14a12ed8195a1b5953597f5baef472019d071be92a91efa1
name: python-mkdocs-obsidian-interactive-graph-plugin-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for mkdocs-obsidian-interactive-graph-plugin
url: https://github.com/daxcore/mkdocs-obsidian-interactive-graph-plugin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkdocs-obsidian-interactive-graph-plugin-0.3.0-1.src.rpm
location_href: Packages/python-mkdocs-obsidian-interactive-graph-plugin-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Plugin for Material for MkDocs to draw an interactive graph like Obsidian.
  The graph inside the sidebar is just available for non-mobile website. The modal view via the button next to the light/dark mode switch shall work on all devices.

  Refer [Github Pages](https://daxcore.github.io/mkdocs-obsidian-interactive-graph-plugin/) for a **demonstration** of the interactive graph in Material for MkDocs.

  [![Build Status](https://github.com/daxcore/mkdocs-obsidian-interactive-graph-plugin/actions/workflows/ci.yml/badge.svg)](https://github.com/daxcore/mkdocs-obsidian-interactive-graph-plugin/actions/workflows/ci.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/mkdocs-obsidian-interactive-graph-plugin)](https://pypi.org/project/mkdocs-obsidian-interactive-graph-plugin/)
  [![PyPi Downloads](https://img.shields.io/pypi/dm/mkdocs-obsidian-interactive-graph-plugin.svg)](https://pypi.org/project/mkdocs-obsidian-interactive-graph-plugin/)
  [![GitHub License](https://img.shields.io/github/license/daxcore/mkdocs-obsidian-interactive-graph-plugin)](https://github.com/daxcore/mkdocs-obsidian-interactive-graph-plugin/blob/main/LICENSE)


  Available on [PyPI](https://pypi.org/project/mkdocs-obsidian-interactive-graph-plugin/).
  Install via `pip install mkdocs-obsidian-interactive-graph-plugin` or add it to your `requirements.txt`.



  Activate the plugin in `mkdocs.yml`, but **note** that this plugin has to be located before plugins, that replace wikilinks by markdown links. Currently just wikilinks like `[[Link#Anchor|Custom Text]]` are supported.
  ```
  plugins:
    - obsidian-interactive-graph

  extra_javascript:
    - https://fastly.jsdelivr.net/npm/jquery/dist/jquery.min.js
    - https://fastly.jsdelivr.net/npm/echarts/dist/echarts.min.js
    - assets/javascripts/interactive_graph.js

  extra_css:
    - assets/stylesheets/interactive_graph.css
  ```


  A `interactive_graph.js` example can be downloaded from [here](https://raw.githubusercontent.com/daxcore/mkdocs-obsidian-interactive-graph-plugin/main/docs/ObsidianVault/assets/javascripts/interactive_graph.js) and must be located into the docs directory under `docs/YourSiteName/assets/javascripts/interactive_graph.js`.

  Beginning from version 0.3.0 the default graph inside the sidebar was minimized to egdes related to the current page only. The previous behavior can be restored by setting `global` to `true` at line `draw_graph_sidebar(myChart, global=false)` at top of javascript file.


  Adapt the `.env` and `mkdocs.yml` files to your needs. `DEV=ON` will rebuild the `mkdocs-obsidian-interactive-graph-plugin` from local files. If `DEV != ON` the upstream packages of PyPI will be used. Build and start the Docker container via `docker compose up --build [-d]`.


  * https://www.mkdocs.org/
  * https://squidfunk.github.io/mkdocs-material/
  * https://github.com/ndy2/mkdocs-obsidian-support-plugin/tree/main
  * https://github.com/GooRoo/mkdocs-obsidian-bridge
  * https://github.com/blueswen/mkdocs-glightbox
  * https://echarts.apache.org


pkgId: 5ac0d286d2ca03bccc75cea68e859e28f24e1b6c52bbef42635d5c8ddcf6c1af
name: python-mkpipe-extractor-mariadb-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mkpipe-extractor-mariadb
url: https://pypi.org/project/mkpipe-extractor-mariadb/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-extractor-mariadb-0.1.0-1.src.rpm
location_href: Packages/python-mkpipe-extractor-mariadb-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **MkPipe** is a modular, open-source ETL (Extract, Transform, Load) tool that allows you to integrate various data sources and sinks easily. It is designed to be extensible with a plugin-based architecture that supports extractors, transformers, and loaders.



  For more detailed documentation, please visit the [GitHub repository](https://github.com/mkpipe-etl/mkpipe).



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.


pkgId: 35b6ed05e9b7dbab08943e4b4c84aa98e1b5fb1373aba5d8502a67e0ff94f2b1
name: python-mkpipe-extractor-mysql-help
arch: noarch
version: 0.1.12
epoch: 0
release: 1
summary: Development documents and examples for mkpipe-extractor-mysql
url: https://pypi.org/project/mkpipe-extractor-mysql/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-extractor-mysql-0.1.12-1.src.rpm
location_href: Packages/python-mkpipe-extractor-mysql-help-0.1.12-1.noarch.rpm
checksum_type: sha256
description:
  **MkPipe** is a modular, open-source ETL (Extract, Transform, Load) tool that allows you to integrate various data sources and sinks easily. It is designed to be extensible with a plugin-based architecture that supports extractors, transformers, and loaders.



  - Extract data from multiple sources (e.g., PostgreSQL, MongoDB).
  - Transform data using custom Python logic and Apache Spark.
  - Load data into various sinks (e.g., ClickHouse, PostgreSQL, Parquet).
  - Plugin-based architecture that supports future extensions.
  - Cloud-native architecture, can be deployed on Kubernetes and other environments.



  You can install the core package and extractors using pip:


  ```bash
  pip install mkpipe
  ```


  ```bash
  pip install mkpipe-extractor-postgres
  ```


  You can find or contribute new extractors and loaders in the future.



  To run the ETL process, use the following command:

  ```py
  from mkpipe_core.plugins.registry import EXTRACTORS

  def test_postgres_extractor():
      postgres_extractor = EXTRACTORS.get("postgres")
      if not postgres_extractor:
          print("Postgres extractor not found!")
          return
      instance = postgres_extractor()
      instance.extract()

  if __name__ == "__main__":
      test_postgres_extractor()

  ```

  Where `elt.yaml` is your configuration file that specifies the extractors, transformers, and loaders.



  For more detailed documentation, please visit the [GitHub repository](https://github.com/mkpipe-etl/mkpipe).



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.


pkgId: 61fa86c136559d9ad0c368f6c9157e164290caef384c50efd3d133271349b962
name: python-mkpipe-extractor-oracledb-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for mkpipe-extractor-oracledb
url: https://pypi.org/project/mkpipe-extractor-oracledb/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-extractor-oracledb-0.2.0-1.src.rpm
location_href: Packages/python-mkpipe-extractor-oracledb-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  **MkPipe** is a modular, open-source ETL (Extract, Transform, Load) tool that allows you to integrate various data sources and sinks easily. It is designed to be extensible with a plugin-based architecture that supports extractors, transformers, and loaders.



  For more detailed documentation, please visit the [GitHub repository](https://github.com/mkpipe-etl/mkpipe).



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.



  ```yaml
  ...
    connections:
      source:
        host: 'XXX'
        port: 'XXX'
        database: 'XXX'
        user: 'XXX'
        password: 'XXX'
  ...
  ```


pkgId: aace86819669ed05087a9bca2c8ecde6dc57b1c7204b6c6502946915d8fb3267
name: python-mkpipe-extractor-redshift-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for mkpipe-extractor-redshift
url: https://pypi.org/project/mkpipe-extractor-redshift/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-extractor-redshift-0.1.1-1.src.rpm
location_href: Packages/python-mkpipe-extractor-redshift-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  **MkPipe** is a modular, open-source ETL (Extract, Transform, Load) tool that allows you to integrate various data sources and sinks easily. It is designed to be extensible with a plugin-based architecture that supports extractors, transformers, and loaders.



  For more detailed documentation, please visit the [GitHub repository](https://github.com/mkpipe-etl/mkpipe).



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.



  ```yaml
  ...
    connections:
      source:
        host: 'XXX'
        port: 'XXX'
        database: 'XXX'
        schema: 'XXX'
        user: 'XXX'
        password: 'XXX'
  ...
  ```


pkgId: cb07c62cb8e0ad146da4e0717d231f804abd2d54ab8cef290aeb3215bccf518d
name: python-mkpipe-extractor-sqlite-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for mkpipe-extractor-sqlite
url: https://pypi.org/project/mkpipe-extractor-sqlite/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-extractor-sqlite-0.1.2-1.src.rpm
location_href: Packages/python-mkpipe-extractor-sqlite-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  **MkPipe** is a modular, open-source ETL (Extract, Transform, Load) tool that allows you to integrate various data sources and sinks easily. It is designed to be extensible with a plugin-based architecture that supports extractors, transformers, and loaders.



  For more detailed documentation, please visit the [GitHub repository](https://github.com/mkpipe-etl/mkpipe).



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.



  ```yaml
  ...
    connections:
      source:
        db_path: '/full_path/sqlite_db.db'
  ...
  ```


pkgId: b763a8aed21d76b8b4d960476e2085055e53358c0064fde3158987bd10704104
name: python-mkpipe-help
arch: noarch
version: 0.1.44
epoch: 0
release: 1
summary: Development documents and examples for mkpipe
url: https://pypi.org/project/mkpipe/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-0.1.44-1.src.rpm
location_href: Packages/python-mkpipe-help-0.1.44-1.noarch.rpm
checksum_type: sha256
description:
  - [ ]  MongoDB
  - [ ]  Cassandra
  - [ ]  DynamoDB
  - [ ]  Redis
  - [ ]  Azure Data Lake Storage (ADLS)
  - [ ]  Google Cloud Storage
  - [ ]  Elasticsearch
  - [ ]  TimescaleDB
  - [ ]  HDFS


pkgId: b9fefb24942847fcd157daa34077d0d8991e905f2d873799c9aaa08a38729f93
name: python-mkpipe-loader-mysql-help
arch: noarch
version: 0.1.13
epoch: 0
release: 1
summary: Development documents and examples for mkpipe-loader-mysql
url: https://pypi.org/project/mkpipe-loader-mysql/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkpipe-loader-mysql-0.1.13-1.src.rpm
location_href: Packages/python-mkpipe-loader-mysql-help-0.1.13-1.noarch.rpm
checksum_type: sha256
description:
  **MkPipe** is a modular, open-source ETL (Extract, Transform, Load) tool that allows you to integrate various data sources and sinks easily. It is designed to be extensible with a plugin-based architecture that supports extractors, transformers, and loaders.



  - Extract data from multiple sources (e.g., PostgreSQL, MongoDB).
  - Transform data using custom Python logic and Apache Spark.
  - Load data into various sinks (e.g., ClickHouse, PostgreSQL, Parquet).
  - Plugin-based architecture that supports future extensions.
  - Cloud-native architecture, can be deployed on Kubernetes and other environments.



  You can install the core package and extractors using pip:


  ```bash
  pip install mkpipe
  ```


  ```bash
  pip install mkpipe-loader-postgres
  ```


  You can find or contribute new extractors and loaders in the future.



  To run the ETL process, use the following command:

  ```py
  from mkpipe_core.plugins.registry import EXTRACTORS

  def test_postgres_extractor():
      postgres_extractor = EXTRACTORS.get("postgresql")
      if not postgres_extractor:
          print("Postgres extractor not found!")
          return
      instance = postgres_extractor()
      instance.extract()

  if __name__ == "__main__":
      test_postgres_extractor()

  ```

  Where `elt.yaml` is your configuration file that specifies the extractors, transformers, and loaders.



  For more detailed documentation, please visit the [GitHub repository](https://github.com/mkpipe-etl/mkpipe).



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.


pkgId: adf775ba2ead3d02964f6ebe1a39f4b00b27e6e08522b168c39eed9fc8ceb448
name: python-mkv-episode-matcher-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for mkv-episode-matcher
url: https://github.com/Jsakkos/mkv-episode-matcher
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mkv-episode-matcher-0.3.4-1.src.rpm
location_href: Packages/python-mkv-episode-matcher-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Development Status](https://img.shields.io/pypi/status/mkv-episode-matcher)](https://pypi.org/project/mkv-episode-matcher/)
  [![PyPI version](https://img.shields.io/pypi/v/mkv-episode-matcher.svg)](https://pypi.org/project/mkv-episode-matcher/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Documentation Status](https://img.shields.io/github/actions/workflow/status/Jsakkos/mkv-episode-matcher/documentation.yml?label=docs)](https://jsakkos.github.io/mkv-episode-matcher/)
  [![Downloads](https://static.pepy.tech/badge/mkv-episode-matcher)](https://pepy.tech/project/mkv-episode-matcher)
  [![GitHub last commit](https://img.shields.io/github/last-commit/Jsakkos/mkv-episode-matcher)](https://github.com/Jsakkos/mkv-episode-matcher/commits/main)
  [![GitHub issues](https://img.shields.io/github/issues/Jsakkos/mkv-episode-matcher)](https://github.com/Jsakkos/mkv-episode-matcher/issues)
  [![Tests](https://github.com/Jsakkos/mkv-episode-matcher/actions/workflows/tests.yml/badge.svg)](https://github.com/Jsakkos/mkv-episode-matcher/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/gh/Jsakkos/mkv-episode-matcher/branch/main/graph/badge.svg)](https://codecov.io/gh/Jsakkos/mkv-episode-matcher)

  Automatically match and rename your MKV TV episodes using The Movie Database (TMDb).



  - 🎯 **Automatic Episode Matching**: Uses TMDb to accurately identify episodes
  - 📝 **Subtitle Extraction**: Extracts subtitles from MKV files
  - 🔍 **OCR Support**: Handles image-based subtitles
  - 🚀 **Multi-threaded**: Fast processing of multiple files
  - ⬇️ **Subtitle Downloads**: Integration with OpenSubtitles
  - ✨ **Bulk Processing**: Handle entire seasons at once
  - 🧪 **Dry Run Mode**: Test changes before applying



  1. Install the package:
  ```bash
  pip install mkv-episode-matcher
  ```

  2. Run on your show directory:
  ```bash
  mkv-match --show-dir "path/to/your/show" --season 1
  ```



  - Python 3.8 or higher
  - TMDb API key
  - OpenSubtitles account (optional, for subtitle downloads)



  Full documentation is available at [https://jsakkos.github.io/mkv-episode-matcher/](https://jsakkos.github.io/mkv-episode-matcher/)



  ```python
  from mkv_episode_matcher import process_show


  process_show()


  process_show(season=1)


  process_show(season=1, dry_run=True)


  process_show(get_subs=True)
  ```



  MKV Episode Matcher expects your TV shows to be organized as follows:

  ```
  Show Name/
  ├── Season 1/
  │   ├── episode1.mkv
  │   ├── episode2.mkv
  ├── Season 2/
  │   ├── episode1.mkv
  │   └── episode2.mkv
  ```



  1. Fork the repository
  2. Create a feature branch (`git checkout -b feature/amazing-feature`)
  3. Commit your changes (`git commit -m 'Add amazing feature'`)
  4. Push to the branch (`git push origin feature/amazing-feature`)
  5. Open a Pull Request



  Distributed under the MIT License. See `LICENSE` for more information.



  - [TMDb](https://www.themoviedb.org/) for their excellent API
  - [OpenSubtitles](https://www.opensubtitles.com/) for subtitle integration
  - All contributors who have helped improve this project


pkgId: 8adc6c2bde53fb2947d49cb0755a5937844e0eb3b65d1aad84072d3d202167ba
name: python-ml-orchestrator-help
arch: noarch
version: 0.0.13b0
epoch: 0
release: 1
summary: Development documents and examples for ml-orchestrator
url: https://pypi.org/project/ml-orchestrator/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ml-orchestrator-0.0.13b0-1.src.rpm
location_href: Packages/python-ml-orchestrator-help-0.0.13b0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ml-orchestrator)](https://pypi.org/project/ml-orchestrator/)
  [![version](https://img.shields.io/pypi/v/ml-orchestrator)](https://img.shields.io/pypi/v/ml-orchestrator)
  [![License](https://img.shields.io/:license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
  ![OS](https://img.shields.io/badge/ubuntu-blue?logo=ubuntu)
  ![OS](https://img.shields.io/badge/win-blue?logo=windows)
  ![OS](https://img.shields.io/badge/mac-blue?logo=apple)
  [![Tests](https://github.com/DanielAvdar/ml-orchestrator/actions/workflows/ci.yml/badge.svg)](https://github.com/DanielAvdar/ml-orchestrator/actions/workflows/ci.yml)
  [![Code Checks](https://github.com/DanielAvdar/ml-orchestrator/actions/workflows/code-checks.yml/badge.svg)](https://github.com/DanielAvdar/ml-orchestrator/actions/workflows/code-checks.yml)
  [![codecov](https://codecov.io/gh/DanielAvdar/ml-orchestrator/graph/badge.svg?token=N0V9KANTG2)](https://codecov.io/gh/DanielAvdar/ml-orchestrator)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)


pkgId: f07ea06058b054efeb5c20d86984a2fa1eddd392b768da9aa4d8d69a095744dd
name: python-ml4gw-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for ml4gw
url: https://pypi.org/project/ml4gw/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ml4gw-0.6.1-1.src.rpm
location_href: Packages/python-ml4gw-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Torch utilities for training neural networks in gravitational wave physics applications.



  You can install `ml4gw` with pip:

  ```console
  pip install ml4gw
  ```

  To build with a specific version of PyTorch/CUDA, please see the PyTorch installation instructions [here](https://pytorch.org/get-started/previous-versions/) to see how to specify the desired torch version and `--extra-index-url` flag. For example, to install with torch 1.12 and CUDA 11.6 support, you would run

  ```console
  pip install ml4gw torch==1.12.0 --extra-index-url=https://download.pytorch.org/whl/cu116
  ```


  `ml4gw` is also fully compatible with use in Poetry, with your `pyproject.toml` set up like

  ```toml
  [tool.poetry.dependencies]
  python = "^3.8"  # python versions 3.8-3.11 are supported
  ml4gw = "^0.3.0"
  ```

  To build against a specific PyTorch/CUDA combination, consult the PyTorch installation documentation above and specify the `extra-index-url` via the `tool.poetry.source` table in your `pyproject.toml`. For example, to build against CUDA 11.6, you would do something like:

  ```toml
  [tool.poetry.dependencies]
  python = "^3.8"
  ml4gw = "^0.3.0"
  torch = {version = "^1.12", source = "torch"}

  [[tool.poetry.source]]
  name = "torch"
  url = "https://download.pytorch.org/whl/cu116"
  secondary = true
  default = false
  ```

  Note: if you are building against CUDA 11.6 or 11.7, make sure that you are using python 3.8, 3.9, or 3.10. Python 3.11 is incompatible with `torchaudio` 0.13, and the following `torchaudio` version is incompatible with CUDA 11.7 and earlier.


  This library provided utilities for both data iteration and transformation via dataloaders defined in `ml4gw/dataloading` and transform layers exposed in `ml4gw/transforms`. Lower level functions and utilies are defined at the top level of the library and in the `utils` library.

  For example, to train a simple autoencoder using a cost function in frequency space, you might do something like:

  ```python
  import numpy as np
  import torch
  from ml4gw.dataloading import InMemoryDataset
  from ml4gw.transforms import SpectralDensity

  SAMPLE_RATE = 2048
  NUM_IFOS = 2
  DATA_LENGTH = 128
  KERNEL_LENGTH = 4
  DEVICE = "cuda"  # or "cpu", wherever you want to run

  BATCH_SIZE = 32
  LEARNING_RATE = 1e-3
  NUM_EPOCHS = 10

  dummy_data = np.random.randn(NUM_IFOS, DATA_LENGTH * SAMPLE_RATE)





  dataset = InMemoryDataset(
      dummy_data,
      kernel_size=KERNEL_LENGTH * SAMPLE_RATE,
      batch_size=BATCH_SIZE,
      batches_per_epoch=50,
      coincident=False,
      shuffle=True,
      device=DEVICE  # this will move your dataset to GPU up-front if "cuda"
  )


  nn = torch.nn.Sequential(
      torch.nn.Conv1d(
          in_channels=2,
          out_channels=8,
          kernel_size=7
      ),
      torch.nn.ConvTranspose1d(
          in_channels=8,
          out_channels=2,
          kernel_size=7
      )
  ).to(DEVICE)

  optimizer = torch.optim.Adam(nn.parameters(), lr=LEARNING_RATE)

  spectral_density = SpectralDensity(SAMPLE_RATE, fftlength=2).to(DEVICE)

  def loss_function(X, y):
      """
      MSE in frequency domain. Obviously this doesn't
      give you much on its own, but you can imagine doing
      something like masking to just the bins you care about.
      """
      X = spectral_density(X)
      y = spectral_density(y)
      return ((X - y)**2).mean()


  for i in range(NUM_EPOCHS):
      epoch_loss = 0
      for X in dataset:
          optimizer.zero_grad(set_to_none=True)
          assert X.shape == (32, NUM_IFOS, KERNEL_LENGTH * SAMPLE_RATE)
          y = nn(X)

          loss = loss_function(X, y)
          loss.backward()
          optimizer.step()

          epoch_loss += loss.item()
      epoch_loss /= len(dataset)
      print(f"Epoch {i + 1}/{NUM_EPOCHS} Loss: {epoch_loss:0.3e}")
  ```


  As this library is still very much a work in progress, we anticipate that novel use cases will encounter errors stemming from a lack of robustness.
  We encourage users who encounter these difficulties to file issues on GitHub, and we'll be happy to offer support to extend our coverage to new or improved functionality.
  We also strongly encourage ML users in the GW physics space to try their hand at working on these issues and joining on as collaborators!
  For more information about how to get involved, feel free to reach out to [ml4gw@ligo.mit.edu](mailto:ml4gw@ligo.mit.edu) .
  By bringing in new users with new use cases, we hope to develop this library into a truly general-purpose tool which makes DL more accessible for gravitational wave physicists everywhere.


  We are grateful for the support of the U.S. National Science Foundation (NSF) Harnessing the Data Revolution (HDR) Institute for <a href="https://a3d3.ai">Accelerating AI Algorithms for Data Driven Discovery (A3D3)</a> under Cooperative Agreement No. <a href="https://www.nsf.gov/awardsearch/showAward?AWD_ID=2117997">PHY-2117997</a>.


pkgId: 2989613f74962314300b0fb5136761449cac1e7fe23137bd36c99cb1c0b78ee3
name: python-mlable-help
arch: noarch
version: 0.14.10
epoch: 0
release: 1
summary: Development documents and examples for mlable
url: https://pypi.org/project/mlable/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlable-0.14.10-1.src.rpm
location_href: Packages/python-mlable-help-0.14.10-1.noarch.rpm
checksum_type: sha256
description:
  Tensorflow libs:

  - [layers](#layers):
      - reshaping:
          - [Divide](#divide)
          - [Merge](#merge)
      - embedding:
          - [TokunEmbedding](#TokunEmbedding)
          - [RotaryPositionalEmbedding](#RotaryPositionalEmbedding)
      - transformer:
          - [CachedMultiHeadAttention](#CachedMultiHeadAttention)
          - [FeedForwardGate](#FeedForwardGate)
  - [metrics](#layers):
      - [BinaryGroupAccuracy](#BinaryGroupAccuracy)
      - [CategoricalGroupAccuracy](#CategoricalGroupAccuracy)
      - [RawGroupAccuracy](#RawGroupAccuracy)



  The package is available on pypi:

  ```python
  pip install -U mlable
  ```





  Relative reshaping layers that divides a given axis and multiplies another by the same factor:

  ```python
  import mlable.layers.reshaping

  __x = tf.ones(shape=(2, 4, 6, 8))
  __l = mlable.layers.reshaping.Divide(
      input_axis=2, # relative to the NEW shape / rank
      output_axis=-1, # same
      factor=3,
      insert=False,) # whether to create a new axis

  list(__l(__x).shape)

  ```



  Relative reshaping layers that merges two axes:

  ```python
  import mlable.layers.reshaping

  __x = tf.ones(shape=(2, 4, 6, 8))
  __l = mlable.layers.reshaping.Merge(
      left_axis=1,
      right_axis=-1,
      left=False,) # whether to merge into the left axis

  list(__l(__x).shape)

  ```



  These embeddings are made from the combination of elementary embeddings.

  The layer inherits from `keras.layers.Embedding`.
  It expects a tensor with a shape following the structure:

  - axis `-2`: sequence axis, with dimension `S / T`
  - axis `-1`: token axis, with dimension `T`

  The `T` values in the token axis are the indexes of the embeddings to be combined.
  Typically, these are byte values:

  ```python
  import mlable.layers.embedding

  __x = tf.random.uniform((128, 1024, 16), minval=0, maxval=256, dtype=int32)
  __l = mlable.layers.embedding.TokunEmbedding(
      input_dim=256,
      output_dim=128,)

  list(__l(__x).shape)

  ```

  And the output tensor has a shape `(..., S / T, T * E)`, where `T * E = H` is the embedding dimension inside the LLM.
  In the above example, it is set to 2048.



  Tensorflow implementation of [RoPE][arxiv-rope]:

  ```python
  import mlable.layers.embedding

  __x = tf.ones(shape=(2, 3, 5))
  __l = mlable.layers.embedding.RotaryPositionalEmbedding(
      sequence_axis=1, # position along this axis
      feature_axis=-1, # output axis
      max_wavelength=10_000, # see the paper
      scaling_factor=1.) # see the paper

  __l(inputs=__x, offset=2) # the offset is typically used to perform iterative decoding during inference
  ```



  This layer subclasses the regular [MultiHeadAttention][docs-tf-multiheadattention] and adds a cache.

  It has the same parameters:

  ```python
  import mlable.layers.transformer

  mlable.layers.transformer.CachedMultiHeadAttention(
      num_heads,
      key_dim,
      value_dim=None,
      dropout=0.0,
      use_bias=True,
      output_shape=None,
      attention_axes=None,
      kernel_initializer='glorot_uniform',
      bias_initializer='zeros',
      kernel_regularizer=None,
      bias_regularizer=None,
      activity_regularizer=None,
      kernel_constraint=None,
      bias_constraint=None,
      **kwargs)
  ```

  And its `call` function has the following arguments:

  ```python
  mlable.layers.transformer.CachedMultiHeadAttention.call(
      query,
      value,
      key=None,
      cache=None,
      step=None,
      training=False,
      attention_mask=None,
      return_attention_scores=False,
      use_causal_mask=True,)
  ```



  A typical feed-forward layer with GELU activation:

  ```python
  import mlable.layers.transformer

  __x = tf.ones(shape=(2, 3, 5), dtype=tf.dtypes.float32)
  __l = mlable.layers.transformer.FeedForwardGate(
      input_dim=256,
      hidden_dim=1024)

  __l(__x)
  ```



  Hierarchical models should not be scored on individual predictions but on their combination.

  For example, [tokun][github-tokun] is a byte level autoencoder.
  It predicts probabilities for each byte of the output, like 0 in the UTF-32-BE encoding of "a" `(0, 0, 0, 97)`.

  A prediction of `(0, 0, 0, 98)` for "a" has 3 correct byte out of 4, but the prediction is actually "b".

  In this case the byte accuracy is 75% while the character accuracy is 0%.
  Having several hierarchies of scoring helps with training and evaluation.

  The individual predictions are evaluated in groups forming logical entities.
  These predictions can be in binary, categorical or raw formats.
  Each of these formats has a dedicated metric.



  Arguments:

  - `group`: the number of elementary predictions that must be correct to predict a higher level entity
  - `depth`: the dimension of the binary embedding for each predicted value
  - `threshold`: probabilities below the threshold are scored as `0` and above `1`

  ```python
  import mlable.metrics

  byte_accuracy = mlable.metrics.BinaryGroupAccuracy(group=1, depth=8, threshold=0.6, name='byte_accuracy')
  character_accuracy = mlable.metrics.BinaryGroupAccuracy(group=4, depth=8, threshold=0.6, name='character_accuracy')
  token_accuracy = mlable.metrics.BinaryGroupAccuracy(group=64, depth=8, threshold=0.6, name='token_accuracy')
  ```



  Arguments:

  - `group`: the number of elementary predictions that must be correct to predict a higher level entity

  ```python
  import mlable.metrics

  byte_accuracy = mlable.metrics.CategoricalGroupAccuracy(group=1, name='byte_accuracy')
  character_accuracy = mlable.metrics.CategoricalGroupAccuracy(group=4, name='character_accuracy')
  token_accuracy = mlable.metrics.CategoricalGroupAccuracy(group=64, name='token_accuracy')
  ```



  Arguments:

  - `group`: the number of elementary predictions that must be correct to predict a higher level entity
  - `factor`: scaling factor, typically from a probability distribution to a numeric value

  ```python
  import mlable.metrics

  byte_accuracy = mlable.metrics.RawGroupAccuracy(group=1, factor=256.0, name='byte_accuracy')
  character_accuracy = mlable.metrics.RawGroupAccuracy(group=4, factor=256.0, name='character_accuracy')
  token_accuracy = mlable.metrics.RawGroupAccuracy(group=64, factor=256.0, name='token_accuracy')
  ```



  [Andrej Karpathy][video-karpathy] reconnected my ML synapses with [micrograd][code-micrograd].



  Licensed under the [aGPLv3](LICENSE.md).

  [arxiv-rope]: https://arxiv.org/pdf/2104.09864
  [code-micrograd]: https://github.com/karpathy/micrograd
  [docs-tf-multiheadattention]: https://www.tensorflow.org/api_docs/python/tf/keras/layers/MultiHeadAttention
  [github-tokun]: https://github.com/apehex/tokun
  [video-karpathy]: https://www.youtube.com/@AndrejKarpathy/videos


pkgId: 1ccd4b0d3edd9faecf199693404ed61f5060f036bb9ad067114124bf9654c632
name: python-mlba-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for mlba
url: https://github.com/gedeck/mlba-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlba-2.0.2-1.src.rpm
location_href: Packages/python-mlba-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://badge.fury.io/py/mlba.svg)](https://pypi.org/project/mlba/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mlba)](https://pypi.org/project/mlba/)
  ![Python](https://github.com/gedeck/mlba-python/actions/workflows/build.yml/badge.svg)



  Collection of utility functions used in the book

  > _Machine Mining for Business Analytics: Concepts, Techniques, and Applications in Python_ (Second Edition)
  > Galit Shmueli, Peter C. Bruce, Peter Gedeck, and Nitin R. Patel
  > (c) 2025 John Wiley & Sons, Inc.

  Code for the book and the used datasets are available on https://www.dataminingbook.com/book/python-edition.



  Use `pip` to install the `mlba` package from pypi (https://pypi.org/project/mlba/).
  ```
  pip install mlba
  ```
  Should this not work, for example when you are behind a firewall, download the package from pypi and install from file, e.g.
  ```
  pip install mlba-2.0.tar.gz
  ```


pkgId: b90c58989a1b5b0700b2ae776d8d1414a275fba5bc41b77fc7646255517f786a
name: python-mlflow-oidc-auth-help
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Development documents and examples for mlflow-oidc-auth
url: https://pypi.org/project/mlflow-oidc-auth/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlflow-oidc-auth-3.1.0-1.src.rpm
location_href: Packages/python-mlflow-oidc-auth-help-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Mlflow auth plugin to use OpenID Connect (OIDC) as authentication and authorization provider




  To get full version (with entire MLFlow and all dependencies) run:
  ```bash
  python3 -m pip install mlflow-oidc-auth[full]
  ```

  To get skinny version run:
  ```bash
  python3 -m pip install mlflow-oidc-auth
  ```


  The plugin required the following environment variables but also supported `.env` file


  | Parameter | Description|
  |---|---|
  | OIDC_REDIRECT_URI      |  Application redirect/callback url (https://example.com/callback) |
  | OIDC_DISCOVERY_URL     | OIDC Discovery URL |
  | OIDC_CLIENT_SECRET     | OIDC Client Secret |
  | OIDC_CLIENT_ID         |  OIDC Client ID |
  | OIDC_GROUP_DETECTION_PLUGIN | OIDC plugin to detect groups |
  | OIDC_PROVIDER_DISPLAY_NAME | any text to display |
  | OIDC_SCOPE | OIDC scope |
  | OIDC_GROUP_NAME | User group name to be allowed login to MLFlow, currently supported groups in OIDC claims and Microsoft Entra ID groups |
  | OIDC_ADMIN_GROUP_NAME | User group name to be allowed login to MLFlow manage and define permissions, currently supported groups in OIDC claims and Microsoft Entra ID groups |
  | OIDC_AUTHORIZATION_URL | OIDC Auth URL (if discovery URL is not defined) |
  | OIDC_TOKEN_URL         | OIDC Token URL (if discovery URL is not defined) |
  | OIDC_USER_URL          | OIDC User info URL (if discovery URL is not defined) |
  | SECRET_KEY             | Key to perform cookie encryption |
  | OAUTHLIB_INSECURE_TRANSPORT | Development only. Allow to use insecure endpoints for OIDC |
  | LOG_LEVEL                   | Application log level |
  | OIDC_USERS_DB_URI | Database connection string |


  | Parameter | Description | Default |
  |---|---|---|
  | SESSION_TYPE | Flask session type (filesystem or redis supported) | filesystem |
  | SESSION_FILE_DIR | The directory where session files are stored | flask_session |
  | SESSION_PERMANENT | Whether use permanent session or not | False |
  | PERMANENT_SESSION_LIFETIME | Server-side session expiration time (in seconds) | 86400 |
  | SESSION_KEY_PREFIX | A prefix that is added before all session keys | mlflow_oidc: |
  | REDIS_HOST | Redis hostname | localhost |
  | REDIS_PORT | Redis port | 6379 |
  | REDIS_DB | Redis DB number | 0 |
  | REDIS_USERNAME | Redis username | None |
  | REDIS_PASSWORD | Redis password | None |
  | REDIS_SSL | Use SSL | false |





  ```bash
  OIDC_DISCOVERY_URL = 'https://<your_domain>.okta.com/.well-known/openid-configuration'
  OIDC_CLIENT_SECRET ='<super_secret>'
  OIDC_CLIENT_ID ='<client_id>'
  OIDC_PROVIDER_DISPLAY_NAME = "Login with Okta"
  OIDC_SCOPE = "openid,profile,email,groups"
  OIDC_GROUP_NAME = "mlflow-users-group-name"
  OIDC_ADMIN_GROUP_NAME = "mlflow-admin-group-name"
  ```



  ```bash
  OIDC_DISCOVERY_URL = 'https://login.microsoftonline.com/<tenant_id>/v2.0/.well-known/openid-configuration'
  OIDC_CLIENT_SECRET = '<super_secret>'
  OIDC_CLIENT_ID = '<client_id>'
  OIDC_PROVIDER_DISPLAY_NAME = "Login with Microsoft"
  OIDC_GROUP_DETECTION_PLUGIN = 'mlflow_oidc_auth.plugins.group_detection_microsoft_entra_id'
  OIDC_SCOPE = "openid,profile,email"
  OIDC_GROUP_NAME = "mlflow_users_group_name"
  OIDC_ADMIN_GROUP_NAME = "mlflow_admins_group_name"
  ```

  > please note, that for getting group membership information, the application should have "GroupMember.Read.All" permission



  Preconditions:

  The following tools should be installed for local development:

  * git
  * nodejs
  * Python

  ```shell
  git clone https://github.com/data-platform-hq/mlflow-oidc-auth
  cd mlflow-oidc-auth
  ./scripts/run-dev-server.sh
  ```


  Apache 2 Licensed. For more information please see [LICENSE](./LICENSE)


  https://github.com/mlflow/mlflow/tree/master/mlflow/server/auth

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright Copyright 2024 EPAM Systems, Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


