# packages

pkgId: 2d6c63f6e193f1c90bd27580d73c30214c442f20cca9a3d3d6dabae38d292d89
name: python-mllm-help
arch: noarch
version: 0.1.53
epoch: 0
release: 1
summary: Development documents and examples for mllm
url: https://pypi.org/project/mllm/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mllm-0.1.53-1.src.rpm
location_href: Packages/python-mllm-help-0.1.53-1.noarch.rpm
checksum_type: sha256
description:
  <!-- PROJECT LOGO -->
  <br />
  <p align="center">
    <!-- <a href="https://github.com/agentsea/skillpacks">
      <img src="https://project-logo.png" alt="Logo" width="80">
    </a> -->

    <h1 align="center">MLLM</h1>

    <p align="center">
      Multimodal Large Language Models
      <br />
      <a href="https://docs.hub.agentsea.ai/introduction"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <a href="https://youtu.be/exoOUUwFRB8">View Demo</a>
      ·
      <a href="https://github.com/agentsea/mllm/issues">Report Bug</a>
      ·
      <a href="https://github.com/agentsea/mllm/issues">Request Feature</a>
    </p>
    <br>
  </p>



  ```sh
  pip install mllm
  ```



  Some features might require extra dependencies.

  For example, for the Gemini models, you can install the extra dependencies like this:

  ```sh
  pip install mllm[gemini]
  ```



  Create an MLLM router with a list of preferred models

  ```python
  import os
  from mllm import Router

  os.environ["OPENAI_API_KEY"] = "..."
  os.environ["ANTHROPIC_API_KEY"] = "..."
  os.environ["GEMINI_API_KEY"] = "..."

  router = Router(
      preference=["gpt-4-turbo", "anthropic/claude-3-opus-20240229", "gemini/gemini-1.5-pro-latest"]
  )
  ```

  Create a new role based chat thread

  ```python
  from mllm import RoleThread

  thread = RoleThread(owner_id="dolores@agentsea.ai")
  thread.post(role="user", msg="Describe the image", images=["data:image/jpeg;base64,..."])
  ```

  Chat with the MLLM, store the prompt data in the namespace `foo`

  ```python
  response = router.chat(thread, namespace="foo")
  thread.add_msg(response.msg)
  ```

  Ask for a structured response

  ```python
  from pydantic import BaseModel

  class Animal(BaseModel):
      species: str
      color: str

  thread.post(
      role="user",
      msg=f"What animal is in this image? Please output as schema {Animal.model_json_schema()}",
      images=["data:image/jpeg;base64,..."]
  )

  response = router.chat(thread, namespace="animal", expect=Animal)
  animal_parsed = response.parsed

  assert type(animal_parsed) == Animal
  ```

  Find a saved thread or a prompt

  ```python
  RoleThread.find(id="123")
  Prompt.find(id="456)
  ```

  To store a raw openai prompt

  ```python
  from mllm import Prompt, RoleThread, RoleMessage

  thread = RoleThread()

  msg = {
      "role": "user",
      "content": [
          {
              "type": "text",
              "text": "Whats in this image?",
          },
          {
              "type": "image_url",
              "image_url": {"url": f"data:image/jpeg;base64,..."},
          }
      ]
  }
  role_message = RoleMessage.from_openai(msg)
  thread.add_msg(role_message)

  response = call_openai(thread.to_openai())
  response_msg = RoleMessage.from_openai(response["choices"][0]["message"])

  saved_prompt = Prompt(thread, response_msg, namespace="foo")
  ```

  Add images of any variety to the thread. We support base64, filepath, PIL, and URL

  ```python
  from PIL import Image

  img1 = Image.open("img1.png")

  thread.post(
    role="user",
    msg="Whats this image?",
    images=["data:image/jpeg;base64,...", "./img1.png", img1, "https://shorturl.at/rVyAS"]
  )
  ```



  Custom endpoints are supported. They can be added to a `Router` instance with the `RouterConfig`:

  ```python
  from mllm import RouterConfig
  custom_model = RouterConfig(
      model="hosted_vllm/allenai/Molmo-7B-D-0924", # needs to have the `hosted_vllm` prefix
      api_base="https://hosted-vllm-api.co", # set your api base here
      api_key_name="MOLMO_API_KEY" # add the api key name -- this will be searched for in your env
  )
  router = Router(custom_model)
  ```

  You can also mix the models:

  ```python
  router = Router([custom_model, "gpt-4-turbo"])
  ```



  MLLM is integrated with:

  - [Taskara](https://github.com/agentsea/taskara) A task management library for AI agents
  - [Skillpacks](https://github.com/agentsea/skillpacks) A library to fine tune AI agents on tasks.
  - [Surfkit](https://github.com/agentsea/surfkit) A platform for AI agents
  - [Threadmem](https://github.com/agentsea/threadmem) A thread management library for AI agents



  Come join us on [Discord](https://discord.gg/hhaq7XYPS6).



  Thread and prompt storage can be backed by:

  - Sqlite
  - Postgresql

  Sqlite will be used by default. To use postgres simply configure the env vars:

  ```sh
  DB_TYPE=postgres
  DB_NAME=mllm
  DB_HOST=localhost
  DB_USER=postgres
  DB_PASS=abc123
  ```

  Thread image storage by default will utilize the db, to configure bucket storage using GCS:

  - Create a bucket with fine grained permissions
  - Create a GCP service account JSON with permissions to write to the bucket

  ```sh
  export THREAD_STORAGE_SA_JSON='{
    "type": "service_account",
    ...
  }'
  export THREAD_STORAGE_BUCKET=my-bucket
  ```


pkgId: 3b1a419b7bdeb0b1bd08934dac1d6397878b82c0c916e388efa86fbfa33d1aa0
name: python-mlmodel-package
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/mlmodel-package/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlmodel-package-0.1-1.src.rpm
location_href: Packages/python-mlmodel-package-0.1-1.noarch.rpm
checksum_type: sha256
description:
  This package allows you to load and use machine learning models and scalers stored remotely. It supports downloading models and scalers from URLs and making predictions.



  You can install the package using `pip`:


pkgId: fff72a13d4d16ee4747901883724e6906bab6ec9f61ea99ffe314552129c5dff
name: python-mloptiflow-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for mloptiflow
url: https://gitlab.com/mloptiflow/mloptiflow
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mloptiflow-0.0.10-1.src.rpm
location_href: Packages/python-mloptiflow-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  Python framework and library with an integrated CLI, designed to streamline ML lifecycle management by automating project inception, real-time model monitoring, and adaptive canary deployment processes. The library facilitates automated project setup across various configurable ML paradigms (whether it is a Random Forest classification, XGBoost regression, T5-based time-series forecasting, encoder-only / encoder-decoder / decoder-only transformer-based NLP downstream tasks, or practically any other configurable ML paradigm) with optimized directories, subdirectories and configuration files adhering to recommended practices in ML development. The library features a plugin architecture for extensibility, allowing integration with other core components / packages, such as real-time model monitoring with anomaly detection mechanisms, adaptive canary deployment architectures, and integrated UI for monitoring and deployment control. Model monitoring is implemented using high-throughput, low-latency data streaming tool Apache Kafka. Deployed ML models act as Kafka producers, emitting real-time inference data and performance metrics serialized with Apache Avro for schema enforcement and efficiency. Model monitoring is accompanied with anomaly, data, and concept drift detection mechanisms via techniques like PSI, Isolation Forests, or LSTM auto-encoders. Adaptive canary deployment architectures and strategies are implemented specifically for ML models using Kubernetes for container orchestration and Istio as a service mesh for traffic management and routing between baseline and canary versions at granular levels. Integrated UI for monitoring and deployment control is implemented using Vanilla JavaScript and Bootstrap on the client-side, and FastAPI / LitServe on the server-side.




  1. create a new virtual environment

  2. install mloptiflow:

  ```bash
  pip install mloptiflow
  ```

  3. initialize a new project and choose a name and paradigm (currently supported paradigms are: `tabular_regression`, `tabular_classification`):

  ```bash
  mloptiflow init <your-project-name> --paradigm=<paradigm-name>
  ```

  4. `cd` into your project directory and (if using `poetry`) update `name` field in `pyproject.toml` file:

  ```bash
  cd <your-project-name>
  ```

  ```toml
  [tool.poetry]
  name = "<your-project-name>"
  ```

  5. install dependencies:

  ```bash
  poetry install
  ```

  or if using `pip`:

  ```bash
  pip install -r requirements.txt
  ```


  1. run the application:

  ```bash
  streamlit run app.py
  ```

  or:

  ```bash
  poetry run streamlit run app.py
  ```

  2. optionally, adjust `Dockerfile` to your needs if you want to run the inference application in a containerized environment:

  ```dockerfile

  WORKDIR /<your-project-name>
  ```

  3. build the container image:

  ```bash
  docker build -t <your-project-name> .
  ```

  4. run the container image:

  ```bash
  docker run -p 8501:8501 <your-project-name>
  ```


  - TBA


  - TBA


  - TBA



  MIT


pkgId: 130376b6629e4b86eebc9844759ddf04fdb7bf4a88a35f023696e101596efe82
name: python-mlquantify-help
arch: noarch
version: 0.0.11.9
epoch: 0
release: 1
summary: Development documents and examples for mlquantify
url: https://github.com/luizfernandolj/QuantifyML/tree/master
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlquantify-0.0.11.9-1.src.rpm
location_href: Packages/python-mlquantify-help-0.0.11.9-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">MLQuantify</h1>
  <h4 align="center">A Python Package for Quantification</h4>

  ___

   **mlquantify** is a Python library for quantification, also known as supervised prevalence estimation, designed to estimate the distribution of classes within datasets. It offers a range of tools for various quantification methods, model selection tailored for quantification tasks, evaluation metrics, and protocols to assess quantification performance. Additionally, mlquantify includes popular datasets and visualization tools to help analyze and interpret results.

  ___



  - **Version 0.0.11.6**: Inicial beta version. For a detailed list of changes, check the [changelog](#).
  - In case you need any help, refer to the [wiki](https://github.com/luizfernandolj/mlquantify/wiki).
  - Explore the [API documentation](#) for detailed developer information.
  - See also the library in the pypi site in [pypi mlquantify](https://pypi.org/project/mlquantify/)

  ___



  To install mlquantify, run the following command:

  ```bash
  pip install mlquantify
  ```

  If you only want to update, run the code below:

  ```bash
  pip install --update mlquantify
  ```

  ___



  | Section | Description |
  |---|---|
  | **21 Quantification Methods** | Methods for quantification, such as classify & Count Correct methods, Threshold Optimization, Mixture Models and more.|
  | **Dynamic class management** | All methods are dynamic, and handles multiclass and binary problems, in case of binary it makes One-Vs-All (OVA) automatically. |
  | **Model Selection** | Criteria and processes used to select the best model, such as grid-search for the case of quantification|
  | **Evaluation Metrics** | Specific metrics used to evaluate quantification performance, (e.g., AE, BIAS, NAE, SE, KLD, etc.). |
  | **Evaluation Protocols** | Evaluation protocols used, based on sampling generation (e.g., APP, NPP, etc.).. |
  | **Plotting Results** | Tools and techniques used to visualize results, such as the protocol results.|
  | **Comprehensive Documentation** | Complete documentation of the project, including code, data, and results. |

  ___



  This code first loads the breast cancer dataset from _sklearn_, which is then split into training and testing sets. It uses the _Expectation Maximisation Quantifier (EMQ)_ with a RandomForest classifier to predict class prevalence. After training the model, it evaluates performance by calculating and printing the absolute error and bias between the real and predicted prevalences.

  ```python
  import mlquantify as mq
  from sklearn.ensemble import RandomForestClassifier
  from sklearn.datasets import load_breast_cancer
  from sklearn.model_selection import train_test_split


  features, target = load_breast_cancer(return_X_y=True)


  X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.3)


  model = mq.methods.EMQ(RandomForestClassifier())
  model.fit(X_train, y_train)


  pred_prevalence = model.predict(X_test)
  real_prevalence = mq.utils.get_real_prev(y_test)


  ae = mq.evaluation.absolute_error(real_prevalence, pred_prevalence)
  bias = mq.evaluation.bias(real_prevalence, pred_prevalence)

  print(f"Mean Squared Error (MSE) -> {ae:.4f}")
  print(f"Bias -> {bias}")
  ```

  ___



  - Scikit-learn
  - pandas
  - numpy
  - joblib
  - tqdm
  - matplotlib
  - xlrd

  ___





  - [Methods](https://github.com/luizfernandolj/mlquantify/wiki/Methods)
  - [Model Selection](https://github.com/luizfernandolj/mlquantify/wiki/Model-Selection)
  - [Evaluation](https://github.com/luizfernandolj/mlquantify/wiki/Evaluation)
  - [Plotting](https://github.com/luizfernandolj/mlquantify/wiki/Plotting)
  - [Utilities](https://github.com/luizfernandolj/mlquantify/wiki/Utilities)


  ___


pkgId: 55f33bdf403c4b401c977860542dd68dc6b5a8e809212c4bf2604f7ca7a7d860
name: python-mls-parser-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for mls-parser
url: https://pypi.org/project/mls-parser/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mls-parser-0.0.5-1.src.rpm
location_href: Packages/python-mls-parser-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Parses an *.mls file (Model Layout Sheet) to yield an abstract syntax tree using python named tuples



  You need to process an *.mls file to layout a model diagram



  Create or use a python 3.11+ environment. Then

  % pip install mls-parser

  At this point you can invoke the parser via the command line or from your python script.



  You need this import statement at a minimum:

      from mls_parser.parser import LayoutParser

  You can then specify a path as shown:

      result = LayoutParser.parse_file(file_input=path_to_file, debug=False)

  In either case, `result` will be a list of parsed class model elements. You may find the header of the `visitor.py`
  file helpful in interpreting these results.



  This is not the intended usage scenario, but may be helpful for testing or exploration. Since the parser
  may generate some diagnostic info you may want to create a fresh working directory and cd into it
  first. From there...

      % mls elevator.mls

  The .xcm extension is not necessary, but the file must contain xcm text. See this repository's wiki for
  more about the mls language. The grammar is defined in the [layout.peg](https://github.com/modelint/mls-parser/blob/main/src/mls_parser/layout.peg) file. (if the link breaks after I do some update to the code,
  just browse through the code looking for the class_model.peg file, and let me know so I can fix it)

  You can also specify a debug option like this:

      % mls elevator.mls -D

  This will create a scrall-diagnostics folder in your current working directory and deposite a couple of PDFs defining
  the parse of both the class model grammar: `class_model_tree.pdf` and your supplied text: `class_model.pdf`.

  You should also see a file named `mls_parser.log` in a diagnostics directory within your working directory

rpm_license:
  MIT License  Copyright (c) 2019-2023 Leon Starr  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: e8477b20a6eec71087026e62cc23fd9c275135f3a4535dd3f0f82d7d6559ea7f
name: python-mlx-omni-server-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for mlx-omni-server
url: https://github.com/madroidmaq/mlx-omni-server
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlx-omni-server-0.2.0-1.src.rpm
location_href: Packages/python-mlx-omni-server-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![alt text](docs/banner.png)

  MLX Omni Server is a local inference server powered by Apple's MLX framework, specifically designed for Apple Silicon (M-series) chips. It implements
  OpenAI-compatible API endpoints, enabling seamless integration with existing OpenAI SDK clients while leveraging the power of local ML inference.



  - 🚀 **Apple Silicon Optimized**: Built on MLX framework, optimized for M1/M2/M3/M4 series chips
  - 🔌 **OpenAI API Compatible**: Drop-in replacement for OpenAI API endpoints
  - 🎯 **Multiple AI Capabilities**:
      - Audio Processing (TTS & STT)
      - Chat Completion
      - Image Generation
  - ⚡ **High Performance**: Local inference with hardware acceleration
  - 🔐 **Privacy-First**: All processing happens locally on your machine
  - 🛠 **SDK Support**: Works with official OpenAI SDK and other compatible clients



  The server implements OpenAI-compatible endpoints:

  - [Chat completions](https://platform.openai.com/docs/api-reference/chat): `/v1/chat/completions`
      - ✅ Chat
      - ✅ Tools, Function Calling
      - ✅ LogProbs
      - 🚧 Vision
  - [Audio](https://platform.openai.com/docs/api-reference/audio)
      - ✅ `/v1/audio/speech` - Text-to-Speech
      - ✅ `/v1/audio/transcriptions` - Speech-to-Text
  - [Models](https://platform.openai.com/docs/api-reference/models/list)
      - ✅ `/v1/models` - List models
      - ✅ `/v1/models/{model}` - Retrieve or Delete model
  - [Images](https://platform.openai.com/docs/api-reference/images)
      - ✅ `/v1/images/generations` - Image generation



  ```bash

  pip install mlx-omni-server
  ```



  1. Start the server:

  ```bash

  mlx-omni-server
  ```

  you can use `--port` to specify a different port,such as: `mlx-omni-server start --port 10240`, default port is 10240.


  2. Use with OpenAI SDK:

  ```python
  from openai import OpenAI


  client = OpenAI(
      base_url="http://localhost:10240/v1",  # Point to local server
      api_key="not-needed"  # API key is not required for local server
  )


  response = client.audio.speech.create(
      model="lucasnewman/f5-tts-mlx",
      input="Hello, welcome to MLX Omni Server!"
  )


  audio_file = open("speech.mp3", "rb")
  transcript = client.audio.transcriptions.create(
      model="mlx-community/whisper-large-v3-turbo",
      file=audio_file
  )


  chat_completion = client.chat.completions.create(
      model="meta-llama/Llama-3.2-3B-Instruct",
      messages=[
          {"role": "user", "content": "What can you do?"}
      ]
  )


  image_response = client.images.generate(
      model="argmaxinc/mlx-FLUX.1-schnell",
      prompt="A serene landscape with mountains and a lake",
      n=1,
      size="512x512"
  )
  ```

  You can view more examples in [examples](examples).



  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.



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



  - Built with [MLX](https://github.com/ml-explore/mlx) by Apple
  - API design inspired by [OpenAI](https://openai.com)
  - Uses [FastAPI](https://fastapi.tiangolo.com/) for the server implementation
  - Chat(text generation) by [mlx-lm](https://github.com/ml-explore/mlx-examples/tree/main/llms/mlx_lm)
  - Image generation by [diffusionkit](https://github.com/argmaxinc/DiffusionKit)
  - Text-to-Speech by [lucasnewman/f5-tts-mlx](https://github.com/lucasnewman/f5-tts-mlx)
  - Speech-to-Text by [mlx-whisper](https://github.com/ml-explore/mlx-examples/blob/main/whisper/README.md)



  This project is not affiliated with or endorsed by OpenAI or Apple. It's an independent implementation that provides OpenAI-compatible APIs using
  Apple's MLX framework.



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


pkgId: 9795c131d2398618269a366bffd6418dc0a07b749b01ae48fc6fe775aec584d1
name: python-mman-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for mman
url: https://miketurkey.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mman-0.0.3-1.src.rpm
location_href: Packages/python-mman-help-0.0.3-1.noarch.rpm
checksum_type: sha256
rpm_license:
  ###################################################################### ####################  SOFTWARE LICENSE   ############################# ######################################################################  mman, Multi-Language, Multi-Platform Man Pager. COPYRIGHT 2024 MikeTurkey (real name: Takaaki Watanabe) Contact: voice[ATmark]miketurkey.com License: GPLv3 License including a prohibition clause for AI training.  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/  ###################################################################### #########  TRANLATED FREEBSD MAN DOCUMENTATION LICENSE  ############## ######################################################################  COPYRIGHT 2024 MikeTurkey (real name: Takaaki Watanabe) FreeBSD man documents were translated by MikeTurkey using Deep-Learning. Contact: voice[ATmark]miketurkey.com License: FreeBSD Document License including a prohibition clause for AI training.  Redistribution and use in source (AsciiDoc) and 'compiled' forms (HTML, PDF, EPUB and so forth) with or without modification, are permitted provided that the following conditions are met:  1.  Redistributions of source code (AsciiDoc) must retain the above copyright notice, this list of conditions and the following disclaimer as the first lines of this file unmodified.  2.  Redistributions in compiled form (Converted to PDF, EPUB and other formats) 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.  ADDITIONAL MACHINE LEARNING PROHIBITION CLAUSE: You may not use this documentation or any part thereof for the purpose of training or developing machine learning models, algorithms, or systems, without prior written permission from the copyright holder. This prohibition applies to any use that involves automated extraction of knowledge or features from the documentation, including but not limited to training neural networks, statistical models, or other artificial intelligence technologies.  THIS DOCUMENTATION IS PROVIDED BY MIKETURKEY "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 MIKETURKEY 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 DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  Manual Pages  Some FreeBSD manual pages contain text from the IEEE Std 1003.1, 2004 Edition, Standard for Information Technology - Portable Operating System Interface (POSIX®) specification. These manual pages are subject to the following terms:  The Institute of Electrical and Electronics Engineers and The Open Group, have given us permission to reprint portions of their documentation.  In the following statement, the phrase "this text" refers to portions of the system documentation.  Portions of this text are reprinted and reproduced in electronic form in the FreeBSD manual pages, from IEEE Std 1003.1, 2004 Edition, Standard for Information Technology - Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 6, Copyright© 2001-2004 by the Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of any discrepancy between these versions and the original IEEE and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document. The original Standard can be obtained online at https://www.opengroup.org/membership/forums/platform/unix.  This notice shall appear on any product containing this material.  See also: FDL: https://www.freebsd.org/copyright/freebsd-doc-license/ Mike Turkey: https://miketurkey.com/  ###################################################################### ########  TRANSLATED GNU/LINUX MAN DOCUMENTATION LICENSE  ############ #################  OWNER'S DOCUMENT LICENSE  ######################### ######################################################################  COPYRIGHT 2024 MikeTurkey(real name: Takaaki Watanabe) Man documents were translated by MikeTurkey using Deep-Learning. Contact: voice[ATmark]miketurkey.com License: GFDL1.3 License including a prohibition clause for AI training.  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/  #################################################################### ########  TRANSLATED OPENBSD MAN DOCUMENTATION LICENSE  ############ ####################################################################  COPYRIGHT 2024 MikeTurkey (real name: Takaaki Watanabe) OpenBSD man documents were translated by MikeTurkey using Deep-Learning. Contact: voice[ATmark]miketurkey.com License: 3-Clause BSD License including a prohibition clause for AI training.  Redistribution and use of this documentation, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of the original documentation must retain the above copyright notice, this list of conditions, and the following disclaimer. 2. Redistributions of derivative works must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the redistribution. 3. Neither the name of the MikeTurkey nor the names of contributors may be used to endorse or promote derivative works without specific prior written permission.  4. ADDITIONAL MACHINE LEARNING PROHIBITION CLAUSE: You may not use this documentation or any part thereof for the purpose of training or developing machine learning models, algorithms, or systems, without prior written permission from the copyright holder. This prohibition applies to any use that involves automated extraction of knowledge or features from the documentation, including but not limited to training neural networks, statistical models, or other artificial intelligence technologies.  THIS DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDER(S) 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(S) 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 DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  ###################################################################### ###########  FREEBSD ENGLISH MAN DOCUMENTATION LICENSE  ############## ######################################################################  Copyright 1994-2024 The FreeBSD Project.  Redistribution and use in source (AsciiDoc) and 'compiled' forms (HTML, PDF, EPUB and so forth) with or without modification, are permitted provided that the following conditions are met:  1.  Redistributions of source code (AsciiDoc) must retain the above copyright notice, this list of conditions and the following disclaimer as the first lines of this file unmodified.  2.  Redistributions in compiled form (Converted to PDF, EPUB and other formats) must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  THIS DOCUMENTATION IS PROVIDED BY THE FREEBSD DOCUMENTATION PROJECT "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 FREEBSD DOCUMENTATION PROJECT 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 DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  Manual Pages  Some FreeBSD manual pages contain text from the IEEE Std 1003.1, 2004 Edition, Standard for Information Technology -  Portable Operating System Interface (POSIX®) specification. These manual pages are subject to the following terms:  The Institute of Electrical and Electronics Engineers and The Open Group, have given us permission to reprint portions of their documentation.  In the following statement, the phrase "this text" refers to portions of the system documentation.  Portions of this text are reprinted and reproduced in electronic form in the FreeBSD manual pages, from IEEE Std 1003.1, 2004 Edition, Standard for Information Technology -  Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 6, Copyright© 2001-2004 by the Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of any discrepancy between these versions and the original IEEE and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document. The original Standard can be obtained online at https://www.opengroup.org/membership/forums/platform/unix.  This notice shall appear on any product containing this material.  See also: FDL: https://www.freebsd.org/copyright/freebsd-doc-license/  ###################################################################### ###########  OPENBSD ENGLISH MAN DOCUMENTATION LICENSE  ############## ######################################################################  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 University 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 REGENTS 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 REGENTS 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.  The Institute of Electrical and Electronics Engineers and the American National Standards Committee X3, on Information Processing Systems have given us permission to reprint portions of their documentation.  In the following statement, the phrase ``this text'' refers to portions of the system documentation.  Portions of this text are reprinted and reproduced in electronic form in the second BSD Networking Software Release, from IEEE Std 1003.1-1988, IEEE Standard Portable Operating System Interface for Computer Environments (POSIX), copyright C 1988 by the Institute of Electrical and Electronics Engineers, Inc.  In the event of any discrepancy between these versions and the original IEEE Standard, the original IEEE Standard is the referee document.  In the following statement, the phrase ``This material'' refers to portions of the system documentation.  This material is reproduced with permission from American National Standards Committee X3, on Information Processing Systems.  Computer and Business Equipment Manufacturers Association (CBEMA), 311 First St., NW, Suite 500, Washington, DC 20001-2178.  The developmental work of Programming Language C was completed by the X3J11 Technical Committee.  The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of the Regents of the University of California.


pkgId: a8aa1758a9ca06cffb376196f9c0e73e6438a8b8fa41818687a3d0d3aa726335
name: python-mne-help
arch: noarch
version: 1.9.0
epoch: 0
release: 1
summary: Development documents and examples for mne
url: https://mne.tools/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mne-1.9.0-1.src.rpm
location_href: Packages/python-mne-help-1.9.0-1.noarch.rpm
checksum_type: sha256
description:
  MNE-Python is an open-source Python package for exploring,
  visualizing, and analyzing human neurophysiological data such as MEG, EEG, sEEG,
  ECoG, and more. It includes modules for data input/output, preprocessing,
  visualization, source estimation, time-frequency analysis, connectivity analysis,
  machine learning, statistics, and more.
  Documentation
  ^^^^^^^^^^^^^
  `Documentation`_ for MNE-Python encompasses installation instructions, tutorials,
  and examples for a wide variety of topics, contributing guidelines, and an API
  reference.
  Forum
  ^^^^^^
  The `user forum`_ is the best place to ask questions about MNE-Python usage or
  the contribution process. The forum also features job opportunities and other
  announcements.
  If you find a bug or have an idea for a new feature that should be added to
  MNE-Python, please use the
  `issue tracker <https://github.com/mne-tools/mne-python/issues/new/choose>`__ of
  our GitHub repository.
  Installation
  ^^^^^^^^^^^^
  To install the latest stable version of MNE-Python with minimal dependencies
  only, use pip_ in a terminal:
      $ pip install --upgrade mne
  For more complete instructions, including our standalone installers and more
  advanced installation methods, please refer to the `installation guide`_.
  Get the development version
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  To install the latest development version of MNE-Python using pip_, open a
  terminal and type:
      $ pip install --upgrade https://github.com/mne-tools/mne-python/archive/refs/heads/main.zip
  To clone the repository with `git <https://git-scm.com/>`__, open a terminal
  and type:
      $ git clone https://github.com/mne-tools/mne-python.git
  Dependencies
  ^^^^^^^^^^^^
  The minimum required dependencies to run MNE-Python are:
  - `Python <https://www.python.org>`__ ≥ 3.9
  - `NumPy <https://numpy.org>`__ ≥ 1.23
  - `SciPy <https://scipy.org>`__ ≥ 1.9
  - `Matplotlib <https://matplotlib.org>`__ ≥ 3.6
  - `Pooch <https://www.fatiando.org/pooch/latest/>`__ ≥ 1.5
  - `tqdm <https://tqdm.github.io>`__
  - `Jinja2 <https://palletsprojects.com/p/jinja/>`__
  - `decorator <https://github.com/micheles/decorator>`__
  - `lazy-loader <https://pypi.org/project/lazy_loader>`__ ≥ 0.3
  - `packaging <https://packaging.pypa.io/en/stable/>`__
  Contributing
  ^^^^^^^^^^^^
  Please see the `contributing guidelines <https://mne.tools/dev/development/contributing.html>`__ on our documentation website.
  About
  ^^^^^
  +---------+------------+----------------+
  | CI      | |Codecov|  | |Bandit|       |
  +---------+------------+----------------+
  | Package | |PyPI|     | |conda-forge|  |
  +---------+------------+----------------+
  | Docs    | |Docs|     | |Discourse|    |
  +---------+------------+----------------+
  | Meta    | |Zenodo|   | |OpenSSF|      |
  +---------+------------+----------------+
  License
  ^^^^^^^
  MNE-Python is licensed under the BSD-3-Clause license.


pkgId: df014f11d622ea7e0c3601ce98cc84b312927889ea651a8191a30aeccb1fc5ec
name: python-model-config-tests-help
arch: noarch
version: 0.0.9
epoch: 0
release: 1
summary: Development documents and examples for model-config-tests
url: https://github.com/ACCESS-NRI/model-config-tests/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-model-config-tests-0.0.9-1.src.rpm
location_href: Packages/python-model-config-tests-help-0.0.9-1.noarch.rpm
checksum_type: sha256
description:
  This repository houses pytests that are used as part CI checks for model configurations, as well as reusable components of model configuration CI.

  The checksum pytests are used for reproducibility CI checks in this repository. The quick configuration tests are used in any repository that calls `config-pr-1-ci.yml` or is templated by [`ACCESS-NRI/model-configs-template](https://github.com/ACCESS-NRI/model-configs-template). For example, [ACCESS-NRI/access-om2-configs](https://github.com/ACCESS-NRI/access-om2-configs).

  Code from these pytests is adapted from COSIMAS's ACCESS-OM2's [bit reproducibility tests](https://github.com/COSIMA/access-om2/blob/master/test/test_bit_reproducibility.py).





  1. Load payu module - this provides the dependencies needed to run the model

      ```sh
      module use /g/data/vk83/modules
      module load payu/1.1.4
      ```

  2. Create and activate a python virtual environment for installing and running tests

      ```sh
      python3 -m venv <path/to/test-venv> --system-site-packages
      source <path/to/test-venv>/bin/activate
      ```

  3. Either pip install a released version of `model-config-tests`,

      ```sh
      pip install model-config-tests==0.0.1
      ```

      Or to install `model-config-tests` in "editable" mode, first clone the repository, and then run pip install from the repository. This means any changes to the code are reflected in the installed package.

      ```sh
      git clone https://github.com/ACCESS-NRI/model-config-tests/ <path/to/model-config-tests>
      pip install -e <path/to/model-config-tests>
      ```

  4. Checkout an experiment (in this case it is using an ACCESS-OM2 config)

      ```sh
      git clone https://github.com/ACCESS-NRI/access-om2-configs/ <path/to/experiment>
      cd <path/to/experiment>
      git checkout <branch/tag>
      ```

  5. Run the pytests

      ```sh
      model-config-tests
      ```

  6. Once done with testing, deactivate the virtual environment, and if the environment is no longer needed, remove the environment

      ```sh
      deactivate
      rm -rf <path/to/test-venv> # Deletes the test environment
      ```



  The output directory for pytests defaults to `$TMPDIR/test-model-repro` and contains the following subdirectories:

  - `control` - contains copies of the model configuration used for each experiment run in the tests.
  - `lab` - contains `payu` model output directories containing `work` and `archive` sub-directories.

  This output directory also contains files generated by pytests, including the `checksum` directory which is used as part of reproducibility CI workflows.

  To specify a different folder for pytest outputs, use `--output-path` command flag, for example:

  ```sh
  model-config-tests --output-path /some/other/path/for/output
  ```

  By default, the control directory, e.g. the model configuration to test, is the current working directory. This can be set similarly to above by using the
  `--control-path` command flag.

  The path containing the checksum file to check against can also be set using
  `--checksum-path` command flag. The default is the `testing/checksum/historical-<default-model-runtime>hr-checksums.json` file which is stored in the control directory.

  To run only CI reproducibility checksum tests, use `-m checksum`, e.g.

  ```sh
  model-config-tests -m checksum
  ```

  To run quick configuration tests, use the `config` marker. To additionally run
  ACCESS-OM2 specific quick configuration tests, use `access_om2` marker,
  e.g.:

  ```sh
  model-config-tests -m "config or access_om2"
  ```



  The `.github` directory contains many different workflows and actions. This section describes how they are used.



  `CI.yml` and `CD.yml` are used to test, package and upload the `model-config-tests` package that is used by `model-configs`-style repositories across the ACCESS-NRI. These are the only workflows that run on this repository. The others are reusable workflows called by `model-configs`-style repositories, among others.



  The `config-*.yml`, `generate-checksums.yml` and `test-repro.yml` workflows are called by `model-configs`-style repositories to test model configurations. They are stored in this repository to allow a central place to update generic CI used by all model configuration repositories.



  Currently, these repositories make use of the reusable CI:

  - [access-om2-configs](https://github.com/ACCESS-NRI/access-om2-configs)
  - [access-esm1.5-configs](https://github.com/ACCESS-NRI/access-esm1.5-configs)
  - [access-esm1.6-configs](https://github.com/ACCESS-NRI/access-esm1.6-configs)
  - [access-om3-configs](https://github.com/ACCESS-NRI/access-om3-configs)
  - [access-om3-wav-configs](https://github.com/ACCESS-NRI/access-om3-wav-configs)

  Below is information on the use of these workflows.



  The `config-pr-*` Pipeline is a series of workflows that govern the testing, ChatOps and merging procedures of pull requests for model configuration repositories, such as [`ACCESS-NRI/access-om2-configs`](https://github.com/ACCESS-NRI/access-om2-configs).

  Essentially, these files work on two types of configuration branch pull requests in the model configuration repository. More information on the terminology used in model configuration repositories can be found in the `README.md` of the `ACCESS-NRI/model-configs-template` repository. The types of pull requests are:

  - Pull requests into `dev-*`: Allows quick checks of configuration metadata and common mistakes in configurations during PRs into the `dev-*` configuration branches.
  - Pull requests from `dev-*` into `release-*`: Allows both quick checks, as well as a longer, more comprehensive check on the reproducibility of the changes being brought into the `release-*` configuration branch, compared to the previous `release-*` commit. It also acts on 'comment commands' run during the pull request, like `!bump` for updating the version of the configuration ([see the 'Config Tags' section](https://github.com/ACCESS-NRI/model-configs-template/blob/main/README.md) in the `ACCESS-NRI/model-configs-template` repository for more). It is also responsible for the creation of the final config tag and release, once merged.



  The `config-schedule-*` Pipeline is a series of workflows used to check the reproducibility of certain config tags against themselves, every month. This is used as a kind of canary to make sure that we continue to get the same results on the same deployment targets.



  This workflow is used to easily generate the checksums used in the reproducibility checks, for a specific branch of a model configuration repository, if they don't already exist. This is most often used for the initial commit of a checksum to the `release-*` configuration branch.



  This workflow is used to test the reproducibility of a given model repository against historical checksums, and can be used as a standalone workflow.

  Using it has some requirements outside of just filling in the inputs: One must have a valid GitHub Environment (specified by the `environment-name` input) in the calling repository, that has the following `secrets` and `vars` defined:

  - `secrets.SSH_HOST` - hostname for the deployment target
  - `secrets.SSH_HOST_DATA` - hostname for the data mover on the deployment target (if it exists)
  - `secrets.SSH_KEY` - private key for access to the deployment target
  - `secrets.SSH_USER` - username for access to the deployment target
  - `vars.EXPERIMENTS_LOCATION` - directory on the deployment target that will contain all the experiments used during testing of reproducibility across multiple runs of this workflow (ex. `/scratch/some/directory/experiments`)
  - `vars.MODULE_LOCATION` - directory on the deployment target that contains module files for payu used during reproducibility testing (ex. `/g/data/vk83/modules`)
  - `vars.PRERELEASE_MODULE_LOCATION` - directory on the deployment target that contains module files for development version of payu (ex. `/g/data/vk83/prerelease/modules`)



  This comment command allows a repro check from any branch, rather than just the `dev-*` -> `release-*` PR pipeline.

  It requires all the `secrets`/`vars` defined on the caller (as above), as well as `vars.CONFIG_CI_SCHEMA_VERSION`.

  Usage is as follows:

  ```txt
  !test TYPE [commit]
  ```

  Where `TYPE` is a test suite that we support. Currently, this consists of `repro`.

  The commands are all case sensitive and require lower case.

  Using `commit` as an option will commit the result of the test to the PR, provided the commenter has at least `write` permission, and the checksums differ.



  `!test repro`: will compare the `HEAD` of the current PR source branch against the common ancestor on the target branch. For example, in the below diagram we would be comparing generated checksums in `C` against checksums already stored at `A`:

  ```txt
  D   (PR Target Branch)
  |
  | C (PR Source Branch)
  | |
  | B
  |/
  A   (Common Ancestor)
  ```


pkgId: 3d571aabb54ca941d2bf84c6bc45c36c76047bc9c21b731482aa1ff1071a6eea
name: python-model-explorer-circle-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for model-explorer-circle
url: https://pypi.org/project/model-explorer-circle/
rpm_license: Apache Software License (Apache 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-model-explorer-circle-0.1.3-1.src.rpm
location_href: Packages/python-model-explorer-circle-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  Circle adapter is an extension adapter for displaying a Circle model in Model Explorer.

  * [Model Explorer](https://github.com/google-ai-edge/model-explorer)
    * Visulization tool for various type of model graphs such as onnx, tflite, pt2 and mlir.


pkgId: c67228bdcfe7c7892562a5e33650a08385a065e3487fd94eac528ca06cb1f8b6
name: python-model-sqlite-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for model-sqlite
url: https://github.com/DominicDJC/model-sqlite
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-model-sqlite-0.1-1.src.rpm
location_href: Packages/python-model-sqlite-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/model-sqlite.svg)](https://pypi.org/project/model-sqlite/)
  [![Tests](https://github.com/DominicDJC/model-sqlite/actions/workflows/test.yml/badge.svg)](https://github.com/DominicDJC/model-sqlite/actions/workflows/test.yml)
  [![Changelog](https://img.shields.io/github/v/release/DominicDJC/model-sqlite?include_prereleases&label=changelog)](https://github.com/DominicDJC/model-sqlite/releases)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/DominicDJC/model-sqlite/blob/main/LICENSE)

  Create and use SQLite databases with classes



  Install this library using `pip`:
  ```bash
  pip install model-sqlite
  ```


  Usage instructions go here.


pkgId: c435e64e50f13fa82dc7754c74c29bb70d0224e5bb008cd2f90dd30660ed3d72
name: python-model-wrapper-help
arch: noarch
version: 0.2.7
epoch: 0
release: 1
summary: Development documents and examples for model-wrapper
url: https://gitee.com/summry/model-wrapper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-model-wrapper-0.2.7-1.src.rpm
location_href: Packages/python-model-wrapper-help-0.2.7-1.noarch.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

          from model_wrapper import SplitClassModelWrapper

          classes = ['class1', 'class2', 'class3'...]
          X = [[...], [...],]
          y = [0, 0, 1, 2, 1...]

          model = ...
          wrapper = SplitClassModelWrapper(model, classes=classes)
          wrapper.train(X, y, val_size=0.2)

          X_test = [[...], [...],]
          y_test = [0, 1, 1, 2, 1...]
          result = wrapper.evaluate(X_test, y_test)
          

          result = wrapper.predict(X_test)
          

          result = wrapper.predict_classes(X_test)
          

          result = wrapper.predict_proba(X_test)
          

          result = wrapper.predict_classes_proba(X_test)


pkgId: f1f6af18fa93e00df2a0016ff397271588035555b0bb5ae2143214f771583d07
name: python-modelbase-help
arch: noarch
version: 1.57.16
epoch: 0
release: 1
summary: Development documents and examples for modelbase
url: https://gitlab.com/qtb-hhu/modelbase-software
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-modelbase-1.57.16-1.src.rpm
location_href: Packages/python-modelbase-help-1.57.16-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://img.shields.io/badge/DOI-10.1186%2Fs12859--021--04122--7-blue)](https://doi.org/10.1186/s12859-021-04122-7)
  [![pipeline status](https://gitlab.com/qtb-hhu/modelbase-software/badges/main/pipeline.svg)](https://gitlab.com/qtb-hhu/modelbase-software/-/commits/main)
  [![coverage report](https://gitlab.com/qtb-hhu/modelbase-software/badges/main/coverage.svg)](https://gitlab.com/qtb-hhu/modelbase-software/-/commits/main)
  [![Documentation](https://img.shields.io/badge/Documentation-Gitlab-success)](https://qtb-hhu.gitlab.io/modelbase-software/)
  [![PyPi](https://img.shields.io/pypi/v/modelbase)](https://pypi.org/project/modelbase/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
  [![Downloads](https://pepy.tech/badge/modelbase)](https://pepy.tech/project/modelbase)


  modelbase is a python package to help you build and analyze dynamic mathematical models of biological systems. It has originally been designed for the simulation of metabolic systems, but can be used for virtually any processes, in which some substances get converted into others.

  modelbase incorporates an easy construction method to define 'reactions'. A rate law and the stoichiometry need to be specified, and the system of differential equations is assembled automatically.

  modelbase allows 'algebraic modules', which are useful to implement rapid equilibrium or quasi steady-state approximations. In the simplest instance, they allow easy incorporation of conserved quantities.

  modelbase also allows a simple construction of isotope-specific models. This class contains a constructor method that automatically construct all isotope specific versions of a particular reaction. Very cool - check it out!



  Versions 1.0 and 0.4.0 introduced changes not compatible with the previous official
  release 0.2.5. API changes are summarised in [this notebook](docs/source/api-changes.ipynb)

  [Version 0.4.5](https://gitlab.com/qtb-hhu/modelbase-software/-/tags/0.4.5) was the prior stable version

  [Version 0.2.5](https://gitlab.com/qtb-hhu/modelbase-software/-/tags/initial-release)
  is the official release for the submission of the
  mansucript "Building mathematical models of biological systems
  with modelbase, a Python package for semi-automatic ODE assembly
  and construction of isotope-specific models" to the Journal of Open
  Research Software.

  See changelog.md for details on changes of earlier versions.



  If you quickly want to test out modelbase, or do not require assimulo support, install modelbase via

  ```bash
  pip install modelbase
  ```

  To enable assimulo support, the easiest way is to install modelbase via conda. We also recommend using the conda-forge channels.

  ```bash

  conda config --add channels conda-forge


  conda create -n mb39 python=3.9
  conda install -c conda-forge modelbase
  ```



  [GPL 3](https://gitlab.com/qtb-hhu/modelbase-software/blob/main/LICENSE)



  The official documentation is hosted [here on gitlab](https://qtb-hhu.gitlab.io/modelbase-software/).



  If you experience issues using the software please contact us through our [issues](https://gitlab.com/qtb-hhu/modelbase-software/issues) page.



  All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. See our [contribution guide](https://gitlab.com/qtb-hhu/modelbase-software/blob/main/CONTRIBUTING.md) for more information.



  If you use this software in your scientific work, please cite [this article](https://rdcu.be/ckOSa):

  van Aalst, M., Ebenhöh, O. & Matuszyńska, A. Constructing and analysing dynamic models with modelbase v1.2.3: a software update. BMC Bioinformatics 22, 203 (2021)

  - [doi](https://doi.org/10.1186/s12859-021-04122-7)
  - [bibtex file](https://gitlab.com/qtb-hhu/modelbase-software/blob/main/citation.bibtex)


pkgId: ffdd66b7f0d7c076652df2421452cde472c3c58e23836b7b21bd3620582ed492
name: python-modelscope-studio-help
arch: noarch
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for modelscope-studio
url: https://pypi.org/project/modelscope-studio/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-modelscope-studio-0.5.2-1.src.rpm
location_href: Packages/python-modelscope-studio-help-0.5.2-1.noarch.rpm
checksum_type: sha256
description:
  <h1>ModelScope Studio</h1>

  <p align="center">
      <img src="https://modelscope.oss-cn-beijing.aliyuncs.com/modelscope.gif" height="60" style="vertical-align: middle;"/>
      <span style="font-size: 30px; vertical-align: middle;">
      ✖️
      </span>
      <img src="https://github.com/gradio-app/gradio/raw/main/readme_files/gradio.svg" height="60" style="vertical-align: middle;">
  <p>

  <p align="center">
  <a href="https://github.com/modelscope/modelscope-studio">GitHub</a> | 🤖 <a href="https://modelscope.cn/studios/modelscope/modelscope-studio/summary">ModelScope Studio</a> ｜ 🤗 <a href="https://huggingface.co/spaces/modelscope/modelscope-studio">Hugging Face Space</a>
  <br>
    <a href="README-zh_CN.md">中文</a>&nbsp ｜ &nbspEnglish&nbsp ｜ &nbsp<a href="README-ja_JP.md">日本語</a>
  </p>

  `modelscope_studio` is a set of extension component libraries based on gradio 4.x, dedicated to serving the various extension needs of gradio applications within the ModelScope Studio. It mainly focuses on enhancing conversational scenarios, supporting multimodal contexts, and providing assistance for various other specialized scenarios.



  ```sh
  pip install modelscope_studio
  ```



  ```python
  import time
  import gradio as gr
  import modelscope_studio as mgr

  def submit(_input, _chatbot):
      print('text：', _input.text)
      print('files: ', _input.files)
      _chatbot.append([_input, None])
      yield _chatbot
      time.sleep(1)
      _chatbot[-1][1] = [{
          "flushing": False,
          "text": 'bot1: ' + _input.text + '!'
      }, {
          "text": 'bot2: ' + _input.text + '!'
      }]
      yield {
          chatbot: _chatbot,
      }

  with gr.Blocks() as demo:
      chatbot = mgr.Chatbot(height=400)

      input = mgr.MultimodalInput()
      input.submit(fn=submit, inputs=[input, chatbot], outputs=[chatbot])

  demo.queue().launch()
  ```

  ![quickstart](./resources/quickstart.png)



  The currently supported components include:

  - Chatbot: Gradio Chatbot extension component, supports multi-modal content output, multi-bot scenarios, and custom rendering components and event interactions within the conversation content.
  - MultimodalInput: A multi-modal input box, supporting functions such as file upload, recording, and photography.
  - Markdown: Gradio Markdown extension component, supports the output of multi-modal content (audio, video, voice, files, text).
  - Lifecycle: A Lifecycle component for getting the current user's environment information.
  - WaterfallGallery: Gradio Gallery extension component, supports waterfall-style image display.
  - Flow: A Flow component implemented based on [reactflow](https://reactflow.dev/), supports customization of node rendering through a schema.
  - More components...

  For detailed usage, see [Documentation and Examples](https://modelscope.cn/studios/modelscope/modelscope-studio/summary)



  Clone this repo locally:

  ```sh
  git clone git@github.com:modelscope/modelscope-studio.git
  cd modelscope-studio

  pip install -e '.'

  npm install pnpm -g

  pnpm install
  pnpm build
  ```

  Run demo!

  ```sh
  gradio docs/app.py
  ```

  or run a single demo like this:

  ```sh
  gradio docs/components/Chatbot/demos/basic.py
  ```


pkgId: 7c7e18458c695d69a2cc14639fbb9607f008ebfac704dc451e44413929ffcc8e
name: python-modeltasks-help
arch: noarch
version: 0.1.18
epoch: 0
release: 1
summary: Development documents and examples for modeltasks
url: https://gitlab.com/geotom/modeltasks
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-modeltasks-0.1.18-1.src.rpm
location_href: Packages/python-modeltasks-help-0.1.18-1.noarch.rpm
checksum_type: sha256
description:
  An opinionated and lightweight workflow management system and task graph. Born from the desire to have
  a reusable code skeleton for geoprocessing and data pipelines projects this package offers:

  - Write cleaner code code in separate tasks
  - Formulate task dependencies and automatically resolve those as a direct acyclical graph (DAG)
  - Display your models
  - Parallelize concurrent tasks
  - Task configuration
  - Caching and invalidation of intermediate task results based on configuration
  - Easily generate a task graph documentation




  A model consists of individual tasks which formulate their dependence on other tasks. Together they build one or more acyclical directed graphs, which do not allow loops or task repetition. Tasks are implement as subclasses of the ModelTask class. They can be either all defined within one file or within a folder of Python modules. The latter is more practical if the model grows and consists of many tasks.



  **model.py**

  ```
  from modeltasks import Model, ModelTask


  my_model = Model(title='My Model', model_tasks=__file__)


  class TaskA(ModelTask):
      def run (self, logger, workspace):
          logger.info(f'Running an A task in {workspace}')


  class TaskB(ModelTask):
      def run (self, logger, workspace):
          logger.info(f'Running a B task in {workspace}')
  ```



  **Prepare project structure**

  ```
  touch model.py
  mkdir task_modules
  touch task_modules/a_tasks.py
  touch task_modules/b_tasks.py
  ```

  **model.py**

  ```
  from modeltasks import Model


  my_model = Model(title='My Model', model_tasks='task_modules')
  ```

  **a_tasks.py**

  ```
  from modeltasks import ModelTask


  class TaskA(ModelTask):
      def run (self, logger, workspace):
          logger.info(f'Running an A task in {workspace}')
  ```

  **b_tasks.py**

  ```
  from modeltasks import ModelTask


  class TaskB(ModelTask):
      def run (self, logger, workspace):
          logger.info(f'Running a B task in {workspace}')
  ```

  The above code creates a model with two simple tasks. But not a task graph yet because both tasks have not defined:
  - inputs (dependencies)
  - outputs (results)
  - configuration

  Putting tasks into a workflow graph is achieved by defining task inputs and outputs. Let's look at the two example tasks we just created and assume that `TaskB` requires `TaskA` to run first and then use its output.

  **a_tasks.py (With output)**

  ```
  from modeltasks import ModelTask
  from modeltasks.data import VariableOutput


  class TaskA(ModelTask):

      a_output: VariableOutput

      def run (self, logger, workspace):
          logger.info(f'Running an A task in {workspace}')
          self.a_output = 'First I ran task A.'
  ```

  **b_tasks.py (With dependency and output)**

  ```
  from modeltasks import ModelTask
  from modeltasks.data import VariableInput, VariableOutput


  class TaskB(ModelTask):

      a_input: VariableInput = 'a_tasks.TaskA'
      b_output: VariableOutput

      def run (self, logger, workspace):
          logger.info(f'Running an B task in {workspace}')
          self.b_output = f'{self.a_input} Then I ran task B.'
  ```



  To run a model, we need to specify an entry task. This is the task that will be run at the end after all of its required task dependencies have been resolved and their output gathered.

  ```
  python3 model.py --run --task b_tasks.TaskB
  ```



  Sometimes it is helpful to see a visual representation of all the task interdependencies. To render such a visual task graph call your model with:

  ```
  python3 model.py --graph --output=mermaid.md (Mermaid file)
  python3 model.py --graph --output=graph.png (Image file)
  ```



  To learn more about supported input and output types, dependency definition, task schedulers, result caching, etc. head over to the [package documentation](https://gitlab.com/geotom/modeltasks/-/wikis/Modeltasks)



  Please leave feedback, questions, suggestions on the [project's issue tracker](https://gitlab.com/geotom/modeltasks/-/issues).


pkgId: f81c8d3e67e59f59e0ff4046c8cde13a4f1c91b1a80460c0282926170301fb88
name: python-modern-treasury-help
arch: noarch
version: 1.44.1
epoch: 0
release: 1
summary: Development documents and examples for modern-treasury
url: https://github.com/Modern-Treasury/modern-treasury-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-modern-treasury-1.44.1-1.src.rpm
location_href: Packages/python-modern-treasury-help-1.44.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/modern-treasury.svg)](https://pypi.org/project/modern-treasury/)

  The Modern Treasury Python library provides convenient access to the Modern Treasury REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  https://user-images.githubusercontent.com/704302/216504942-09ed8dd7-7f44-40a6-a580-3764e91f11b4.mov



  The REST API documentation can be found on [docs.moderntreasury.com](https://docs.moderntreasury.com). The full API of this library can be found in [api.md](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/api.md).



  ```sh

  pip install modern-treasury
  ```



  The full API of this library can be found in [api.md](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/api.md).

  ```python
  import os
  from modern_treasury import ModernTreasury

  client = ModernTreasury(
      organization_id=os.environ.get(
          "MODERN_TREASURY_ORGANIZATION_ID"
      ),  # This is the default and can be omitted
      api_key=os.environ.get("MODERN_TREASURY_API_KEY"),  # This is the default and can be omitted
  )

  counterparty = client.counterparties.create(
      name="my first counterparty",
  )
  print(counterparty.id)
  ```

  While you can provide a `organization_id` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `MODERN_TREASURY_ORGANIZATION_ID="my-organization-ID"` to your `.env` file
  so that your Organization ID is not stored in source control.



  Simply import `AsyncModernTreasury` instead of `ModernTreasury` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from modern_treasury import AsyncModernTreasury

  client = AsyncModernTreasury(
      organization_id=os.environ.get(
          "MODERN_TREASURY_ORGANIZATION_ID"
      ),  # This is the default and can be omitted
      api_key=os.environ.get("MODERN_TREASURY_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      counterparty = await client.counterparties.create(
          name="my first counterparty",
      )
      print(counterparty.id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  List methods in the Modern Treasury API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from modern_treasury import ModernTreasury

  client = ModernTreasury()

  all_counterparties = []

  for counterparty in client.counterparties.list():
      
      all_counterparties.append(counterparty)
  print(all_counterparties)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from modern_treasury import AsyncModernTreasury

  client = AsyncModernTreasury()


  async def main() -> None:
      all_counterparties = []
      
      async for counterparty in client.counterparties.list():
          all_counterparties.append(counterparty)
      print(all_counterparties)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.counterparties.list()
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.items)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.counterparties.list()

  print(f"next page cursor: {first_page.after_cursor}")  # => "next page cursor: ..."
  for counterparty in first_page.items:
      print(counterparty.id)


  ```



  Nested parameters are dictionaries, typed using `TypedDict`, for example:

  ```python
  from modern_treasury import ModernTreasury

  client = ModernTreasury()

  external_account = client.external_accounts.create(
      counterparty_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
  )
  print(external_account.id)
  ```



  Request parameters that correspond to file uploads can be passed as `bytes`, a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance or a tuple of `(filename, contents, media type)`.

  ```python
  from pathlib import Path
  from modern_treasury import ModernTreasury

  client = ModernTreasury()

  client.documents.create(
      documentable_id="24c6b7a3-02...",
      documentable_type="counterparties",
      file=Path("my/file.txt"),
  )
  ```

  The async client uses the exact same interface. If you pass a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance, the file contents will be read asynchronously automatically.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `modern_treasury.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `modern_treasury.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `modern_treasury.APIError`.

  ```python
  import modern_treasury
  from modern_treasury import ModernTreasury

  client = ModernTreasury()

  try:
      client.external_accounts.create(
          counterparty_id="missing",
      )
  except modern_treasury.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except modern_treasury.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except modern_treasury.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from modern_treasury import ModernTreasury


  client = ModernTreasury(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).counterparties.create(
      name="my first counterparty",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from modern_treasury import ModernTreasury


  client = ModernTreasury(
      
      timeout=20.0,
  )


  client = ModernTreasury(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).counterparties.create(
      name="my first counterparty",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `MODERN_TREASURY_LOG` to `info`.

  ```shell
  $ export MODERN_TREASURY_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from modern_treasury import ModernTreasury

  client = ModernTreasury()
  response = client.counterparties.with_raw_response.create(
      name="my first counterparty",
  )
  print(response.headers.get('X-My-Header'))

  counterparty = response.parse()  # get the object that `counterparties.create()` would have returned
  print(counterparty.id)
  ```

  These methods return an [`LegacyAPIResponse`](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/src/modern_treasury/_legacy_response.py) object. This is a legacy class as we're changing it slightly in the next major version.

  For the sync client this will mostly be the same with the exception
  of `content` & `text` will be methods instead of properties. In the
  async client, all methods will be async.

  A migration script will be provided & the migration in general should
  be smooth.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  As such, `.with_streaming_response` methods return a different [`APIResponse`](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/src/modern_treasury/_response.py) object, and the async client returns an [`AsyncAPIResponse`](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/src/modern_treasury/_response.py) object.

  ```python
  with client.counterparties.with_streaming_response.create(
      name="my first counterparty",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from modern_treasury import ModernTreasury, DefaultHttpxClient

  client = ModernTreasury(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.

  ```py
  from modern_treasury import ModernTreasury

  with ModernTreasury() as client:
    
    ...


  ```



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/Modern-Treasury/modern-treasury-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import modern_treasury
  print(modern_treasury.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/Modern-Treasury/modern-treasury-python/tree/main/./CONTRIBUTING.md).


pkgId: 09636822f10cafade2be59c32ec0bab0d1c4074b58d2e7d908e0a6620c9a625e
name: python-modis-crawler-utils-help
arch: noarch
version: 0.3.36
epoch: 0
release: 1
summary: Development documents and examples for modis-crawler-utils
url: https://gitlab.at.ispras.ru/crawlers/crawler-utils
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-modis-crawler-utils-0.3.36-1.src.rpm
location_href: Packages/python-modis-crawler-utils-help-0.3.36-1.noarch.rpm
checksum_type: sha256
description:
  Scrapy utils for Modis crawlers projects.



  Some utils connected with mongodb.

  MongoDBPipeline - pipeline for saving items in mongodb.

  Params:
  * MONGODB_SERVER - address of mongodb database.
  * MONGODB_PORT - port of mongodb database.
  * MONGODB_DB - database where to save data.
  * MONGODB_USERNAME - username for authentication in MONGODB_DB database.
  * MONGODB_PWD - password for authentication.
  * DEFAULT_MONGODB_COLLECTION - default collection where to save data (default value is `test`).
  * MONGODB_COLLECTION_KEY - key of item which identifies items collection name (`MONGO_COLLECTION`)
   where to save item (default value is `collection`).
  * MONGODB_UNIQUE_KEY - key of item which identifies item



  Some utils connected with kafka.

  KafkaPipeline - pipeline for pushing items into kafka.

  Pipeline outputs data into stream with name `{RESOURCE_TAG}.{DATA_TYPE}`.
  Where `RESOURCE_TAG` is tag of resource from which data is crawled and `DATA_TYPE` is type of
  data crawled: `data`, `post`, `comment`, `like`, `user`, `friend`, `share`, `member`, `news`,
  `community`.

   Params:
  * KAFKA_ADDRESS - address of kafka broker.
  * KAFKA_KEY - key of item which is put into kafka record key.
  * KAFKA_RESOURCE_TAG_KEY - key of item which identifies item `RESOURCE_TAG` (default value is `platform`)
  * KAFKA_DEFAULT_RESOURCE_TAG - default `RESOURCE_TAG` for crawled items without `KAFKA_RESOURCE_TAG_KEY` (default value is `crawler`)
  * KAFKA_DATA_TYPE_KEY - key of item from which identifies item `DATA_TYPE` (default value is `type`).
  * KAFKA_DEFAULT_DATA_TYPE - default `DATA_TYPE` for crawled items without `KAFKA_DATA_TYPE_KEY` (default value is `data`).
  * KAFKA_COMPRESSION_TYPE - type of data compression in kafka for example `gzip`.



  OpenSearchRequestsDownloaderMiddleware transforms request-response pair into an item,
  and then sends it to the OpenSearch.

  Settings:
  ```
  `OPENSEARCH_REQUESTS_SETTINGS` - dict specifying OpenSearch client connections:
      "hosts": Optional[str | list[str]] = "localhost:9200" - hosts with opensearch endpoint,
      "timeout": Optional[int] = 60 - timeout of connections,
      "http_auth": Optional[tuple[str, str]] = None - HTTP authentication if needed,
      "port": Optional[int] = 443 - access port if not specified in hosts,
      "use_ssl": Optional[bool] = True - usage of SSL,
      "verify_certs": Optional[bool] = False - verifying certificates,
      "ssl_show_warn": Optional[bool] = False - show SSL warnings,
      "ca_certs": Optional[str] = None - CA certificate path,
      "client_key": Optional[str] = None - client key path,
      "client_cert": Optional[str] = None - client certificate path,
      "buffer_length": Optional[int] = 500 - number of items in OpenSearchStorage's buffer.

  `OPENSEARCH_REQUESTS_INDEX`: Optional[str] = "scrapy-job-requests" - index in OpenSearch.
  ```

  See an example in examples/opensearch.



  Captcha detection middleware for scrapy crawlers.
  It gets the HTML code from the response (if present), sends it to the captcha detection web-server
  and logs the result.

  If you don't want to check exact response if it has captcha, provide meta-key `dont_check_captcha`
  with `True` value.

  The middleware must be set up with higher precedence (lower number) than RetryMiddleware:
  ```python
  DOWNLOADER_MIDDLEWARES = {
      "crawler_utils.CaptchaDetectionDownloaderMiddleware": 549,  # By default, RetryMiddleware has 550
  }
  ```

  Middleware settings:
  * ENABLE_CAPTCHA_DETECTOR: bool = True. Whether to enable captcha detection.
  * CAPTCHA_SERVICE_URL: str. For an example: http://127.0.0.1:8000



  You may want to log exceptions during crawling to your Sentry.
  Use the `crawler_utils.sentry_logging.SentryLoggingExtension` for this.
  Note that sentry_sdk wants to be loaded as earlier as possible.
  To satisfy this condition make the extension with negative order:
  ```python
  EXTENSIONS = {
      
      "crawler_utils.sentry_logging.SentryLoggingExtension": -1,
  }
  ```

  Settings:

  SENTRY_DSN: str - Sentry's DSN, where to send events.\
  SENTRY_SAMPLE_RATE: float = 1.0 - sample rate for error events. Must be in range from 0.0 to 1.0.\
  SENTRY_TRACES_SAMPLE_RATE: float = 1.0 - the percentage chance a given transaction will be sent to Sentry.\
  SENTRY_ATTACH_STACKTRACE: bool = False - whether to attach stacktrace for error events.\
  SENTRY_MAX_BREADCRUMBS: int = 10 - max breadcrumbs to capture with Sentry.

  For an example, check `examples/sentry_logging`.


pkgId: c0ad02fe36f4c755f0ae1de785295d3edadfef75e74de576b05e22fbdd4a2f16
name: python-modm-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for modm
url: https://modm.io
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-modm-0.2.1-1.src.rpm
location_href: Packages/python-modm-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  This repository currently only contains a simple PyPi package to group modm
  dependencies.

  ```
  pip3 install modm
  ```

  is equivalent to

  ```
  pip3 install lbuild lxml pyelftools telnetlib3
  ```


pkgId: ffe05cf47c2fb9a010a44cf97e3d5ef39765a9a973774bb595c8278630b89e9d
name: python-module-qc-analysis-tools-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for module-qc-analysis-tools
url: https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-analysis-tools
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-module-qc-analysis-tools-2.3.0-1.src.rpm
location_href: Packages/python-module-qc-analysis-tools-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- sync the following div with docs/index.md -->
  <div align="center">
  <!--<img src="https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-analysis-tools/-/raw/main/docs/assets/images/logo.svg" alt="mqat logo" width="500" role="img">-->
  <!-- --8<-- [start:badges] -->
  <!-- prettier-ignore-start -->
  | | |
  | --- | --- |
  | CI/CD | [![CI - Test][cicd-badge]][cicd-link] |
  | Docs | [![Docs - Badge][docs-badge]][docs-link] |
  | Package | [![PyPI - Downloads - Total][pypi-downloads-total]][pypi-link] [![PyPI - Downloads - Per Month][pypi-downloads-dm]][pypi-link] [![PyPI - Version][pypi-version]][pypi-link] [![PyPI platforms][pypi-platforms]][pypi-link] |
  | Meta | [![GitLab - Issue][gitlab-issues-badge]][gitlab-issues-link] [![License - MIT][license-badge]][license-link] |
  [cicd-badge]:            https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-analysis-tools/badges/main/pipeline.svg
  [cicd-link]:             https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-analysis-tools/-/commits/main
  [docs-badge]:            https://img.shields.io/badge/documentation-mkdocs-brightgreen?style=for-the-badge&logo=data:image/png;base64,[encoded data, 5060 characters]
  [docs-link]:                https://atlas-itk-pixel-mqat.docs.cern.ch
  [gitlab-issues-badge]:      https://img.shields.io/static/v1?label=Issues&message=File&color=blue&logo=gitlab
  [gitlab-issues-link]:       https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-analysis-tools/-/issues
  [pypi-link]:                https://pypi.org/project/module-qc-analysis-tools/
  [pypi-downloads-dm]:        https://img.shields.io/pypi/dm/module-qc-analysis-tools.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold
  [pypi-downloads-total]:     https://pepy.tech/badge/module-qc-analysis-tools
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/module-qc-analysis-tools
  [pypi-version]:             https://img.shields.io/pypi/v/module-qc-analysis-tools
  [license-badge]:            https://img.shields.io/badge/License-MIT-blue.svg
  [license-link]:             https://spdx.org/licenses/MIT.html
  <!-- prettier-ignore-end -->
  <!-- --8<-- [end:badges] -->
  </div>

rpm_license:
  Copyright (c) 2022 ATLAS ITk Pixel Modules  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: 319976844fc20c0e9d869d6d9c935fd75ace8b54e02624420712467e34738191
name: python-module-qc-database-tools-help
arch: noarch
version: 2.4.9
epoch: 0
release: 1
summary: Development documents and examples for module-qc-database-tools
url: https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-database-tools
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-module-qc-database-tools-2.4.9-1.src.rpm
location_href: Packages/python-module-qc-database-tools-help-2.4.9-1.noarch.rpm
checksum_type: sha256
description:
  <!-- sync the following div with docs/index.md -->
  <div align="center">
  <!--<img src="https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-database-tools/-/raw/main/docs/assets/images/logo.svg" alt="mqdbt logo" width="500" role="img">-->
  <!-- --8<-- [start:badges] -->
  <!-- prettier-ignore-start -->
  | | |
  | --- | --- |
  | CI/CD | [![CI - Test][cicd-badge]][cicd-link] |
  | Docs | [![Docs - Badge][docs-badge]][docs-link] |
  | Package | [![PyPI - Downloads - Total][pypi-downloads-total]][pypi-link] [![PyPI - Downloads - Per Month][pypi-downloads-dm]][pypi-link] [![PyPI - Version][pypi-version]][pypi-link] [![PyPI platforms][pypi-platforms]][pypi-link] |
  | Meta | [![GitLab - Issue][gitlab-issues-badge]][gitlab-issues-link] [![License - MIT][license-badge]][license-link] |
  [cicd-badge]:            https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-database-tools/badges/main/pipeline.svg
  [cicd-link]:             https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-database-tools/-/commits/main
  [docs-badge]:            https://img.shields.io/badge/documentation-mkdocs-brightgreen?style=for-the-badge&logo=data:image/png;base64,[encoded data, 5060 characters]
  [docs-link]:                https://atlas-itk-pixel-mqdbt.docs.cern.ch
  [gitlab-issues-badge]:      https://img.shields.io/static/v1?label=Issues&message=File&color=blue&logo=gitlab
  [gitlab-issues-link]:       https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-database-tools/-/issues
  [pypi-link]:                https://pypi.org/project/module-qc-database-tools/
  [pypi-downloads-dm]:        https://img.shields.io/pypi/dm/module-qc-database-tools.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold
  [pypi-downloads-total]:     https://pepy.tech/badge/module-qc-database-tools
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/module-qc-database-tools
  [pypi-version]:             https://img.shields.io/pypi/v/module-qc-database-tools
  [license-badge]:            https://img.shields.io/badge/License-MIT-blue.svg
  [license-link]:             https://spdx.org/licenses/MIT.html
  <!-- prettier-ignore-end -->
  <!-- --8<-- [end:badges] -->
  </div>

rpm_license:
  Copyright (c) 2022 ATLAS ITk Pixel Modules  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: 0ce2562cd6f85c392f61d468081eaa319664a78861b7015d227a1918e37163d0
name: python-module-qc-tools-help
arch: noarch
version: 2.2.8
epoch: 0
release: 1
summary: Development documents and examples for module-qc-tools
url: https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-tools
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-module-qc-tools-2.2.8-1.src.rpm
location_href: Packages/python-module-qc-tools-help-2.2.8-1.noarch.rpm
checksum_type: sha256
description:
  <!-- sync the following div with docs/index.md -->
  <div align="center">
  <!--<img src="https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-tools/-/raw/main/docs/assets/images/logo.svg" alt="mqt logo" width="500" role="img">-->
  <!-- --8<-- [start:badges] -->
  <!-- prettier-ignore-start -->
  | | |
  | --- | --- |
  | CI/CD | [![CI - Test][cicd-badge]][cicd-link] |
  | Docs | [![Docs - Badge][docs-badge]][docs-link] |
  | Package | [![PyPI - Downloads - Total][pypi-downloads-total]][pypi-link] [![PyPI - Downloads - Per Month][pypi-downloads-dm]][pypi-link] [![PyPI - Version][pypi-version]][pypi-link] [![PyPI platforms][pypi-platforms]][pypi-link] |
  | Meta | [![GitLab - Issue][gitlab-issues-badge]][gitlab-issues-link] [![License - MIT][license-badge]][license-link] |
  [cicd-badge]:            https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-tools/badges/main/pipeline.svg
  [cicd-link]:             https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-tools/-/commits/main
  [docs-badge]:            https://img.shields.io/badge/documentation-mkdocs-brightgreen?style=for-the-badge&logo=data:image/png;base64,[encoded data, 5060 characters]
  [docs-link]:                https://atlas-itk-pixel-mqt.docs.cern.ch
  [gitlab-issues-badge]:      https://img.shields.io/static/v1?label=Issues&message=File&color=blue&logo=gitlab
  [gitlab-issues-link]:       https://gitlab.cern.ch/atlas-itk/pixel/module/module-qc-tools/-/issues
  [pypi-link]:                https://pypi.org/project/module-qc-tools/
  [pypi-downloads-dm]:        https://img.shields.io/pypi/dm/module-qc-tools.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold
  [pypi-downloads-total]:     https://pepy.tech/badge/module-qc-tools
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/module-qc-tools
  [pypi-version]:             https://img.shields.io/pypi/v/module-qc-tools
  [license-badge]:            https://img.shields.io/badge/License-MIT-blue.svg
  [license-link]:             https://spdx.org/licenses/MIT.html
  <!-- prettier-ignore-end -->
  <!-- --8<-- [end:badges] -->
  </div>

rpm_license:
  Copyright (c) 2018 ATLAS ITk Pixel Modules  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: 66fafa0f608f7ee8e2e5e2edc1418bf66d8c2280305491bee51297475af44b59
name: python-module-typica-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for module-typica
url: https://pypi.org/project/module-typica/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-module-typica-0.2.5-1.src.rpm
location_href: Packages/python-module-typica-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  This is a standardized model library that uses the pydantic library, which is often used in work, especially in database connection, parameter, or response in service, and other utilities. This repository provides a standardized model that can be used in various scenarios. It aims to simplify the process of defining and validating models in Python applications.


  there are several use cases that can be implemented using this library, such as some of the examples below





  [//]: contributor-faces

  <a href="https://github.com/oktapiancaw"><img src="https://avatars.githubusercontent.com/u/48079010?v=4" title="Oktapian Candra" width="80" height="80" style="border-radius: 50%"></a>

  [//]: contributor-faces


pkgId: 951945779bab36d62c8623128fc6f01fd5f3cb55cc609c3308fbd167ae600302
name: python-moe-peft-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for moe-peft
url: https://github.com/TUDB-Labs/MoE-PEFT
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moe-peft-2.0.2-1.src.rpm
location_href: Packages/python-moe-peft-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://github.com/TUDB-Labs/MoE-PEFT/actions/workflows/python-test.yml/badge.svg)](https://github.com/TUDB-Labs/MoE-PEFT/actions/workflows/python-test.yml)
  [![](https://img.shields.io/github/stars/TUDB-Labs/MoE-PEFT?logo=GitHub&style=flat)](https://github.com/TUDB-Labs/MoE-PEFT/stargazers)
  [![](https://img.shields.io/github/v/release/TUDB-Labs/MoE-PEFT?logo=Github)](https://github.com/TUDB-Labs/MoE-PEFT/releases/latest)
  [![](https://img.shields.io/pypi/v/moe_peft?logo=pypi)](https://pypi.org/project/moe_peft/)
  [![](https://img.shields.io/docker/v/mikecovlee/moe_peft?logo=Docker&label=docker)](https://hub.docker.com/r/mikecovlee/moe_peft/tags)
  [![](https://img.shields.io/github/license/TUDB-Labs/MoE-PEFT)](http://www.apache.org/licenses/LICENSE-2.0)

  MoE-PEFT is an open-source *LLMOps* framework built on [m-LoRA](https://github.com/TUDB-Labs/mLoRA). It is designed for high-throughput fine-tuning, evaluation, and inference of Large Language Models (LLMs) using techniques such as MoE + Others (like LoRA, DoRA). Key features of MoE-PEFT include:

  - Concurrent fine-tuning, evaluation, and inference of multiple adapters with a shared pre-trained model.

  - **MoE PEFT** optimization, mainly for [MixLoRA](https://github.com/TUDB-Labs/MixLoRA) and other MoLE implementation.

  - Support for multiple PEFT algorithms and various pre-trained models.

  - Seamless integration with the [HuggingFace](https://huggingface.co) ecosystem.

  You can try MoE-PEFT with [Google Colab](https://colab.research.google.com/github/TUDB-Labs/MoE-PEFT/blob/main/misc/finetune-demo.ipynb) before local installation.



  | OS      | Executor | Model Precision        | Quantization  | Flash Attention |
  |---------|---------|------------------------|---------------|-----------------|
  | Linux   | CUDA    | FP32, FP16, TF32, BF16 | 8bit and 4bit | &check;         |
  | Windows | CUDA    | FP32, FP16, TF32, BF16 | 8bit and 4bit | -               |
  | macOS   | MPS     | FP32, FP16, BF16       | &cross;       | &cross;         |
  | All     | CPU     | FP32, FP16, BF16       | &cross;       | &cross;         |

  You can use the `MOE_PEFT_EXECUTOR_TYPE` environment variable to force MoE-PEFT to use a specific executor. For example, if you want MoE-PEFT to run only on CPU, you can set `MOE_PEFT_EXECUTOR_TYPE=CPU` before importing `moe_peft`.



  |         | Model                                            | Model Size  |
  |---------|--------------------------------------------------|-------------|
  | &check; | [LLaMA 1/2](https://huggingface.co/meta-llama)   | 7B/13B/70B  |
  | &check; | [LLaMA 3/3.1](https://huggingface.co/meta-llama) | 8B/70B      |
  | &check; | [Yi 1/1.5](https://huggingface.co/01-ai)         | 6B/9B/34B   |
  | &check; | [TinyLLaMA](https://huggingface.co/TinyLlama)    | 1.1B        |
  | &check; | [Qwen 1.5/2](https://huggingface.co/Qwen)        | 0.5B ~ 72B  |
  | &check; | [Gemma](https://huggingface.co/google)           | 2B/7B       |
  | &check; | [Gemma 2](https://huggingface.co/google)         | 9B/27B      |
  | &check; | [Mistral](https://huggingface.co/mistralai)      | 7B          |
  | &check; | [Phi 1.5/2](https://huggingface.co/microsoft)    | 2.7B        |
  | &check; | [Phi 3/3.5](https://huggingface.co/microsoft)    | 3.8B/7B/14B |
  | &check; | [ChatGLM 1/2/3](https://huggingface.co/THUDM)    | 6B          |
  | &check; | [GLM 4](https://huggingface.co/THUDM)            | 6B          |




  |         | PEFT Methods                                             | Arguments*                                                |
  |---------|----------------------------------------------------------|-----------------------------------------------------------|
  | &check; | [MoLA](https://arxiv.org/abs/2402.08562)                 | `"routing_strategy": "mola", "num_experts": 8`            |
  | &check; | [LoRAMoE](https://arxiv.org/abs/2312.09979)              | `"routing_strategy": "loramoe", "num_experts": 8`         |
  | &check; | [MixLoRA](https://arxiv.org/abs/2404.15159)              | `"routing_strategy": "mixlora", "num_experts": 8`         |
  | &check; | [LoRA](https://arxiv.org/abs/2106.09685)                 | `"r": 8, "lora_alpha": 16, "lora_dropout": 0.05`          |
  | &check; | [QLoRA](https://arxiv.org/abs/2402.12354)                | See *Quantize Methods*                                    |
  | &check; | [LoRA+](https://arxiv.org/abs/2402.12354)                | `"loraplus_lr_ratio": 20.0`                               |
  | &check; | [DoRA](https://arxiv.org/abs/2402.09353)                 | `"use_dora": true`                                        |
  | &check; | [rsLoRA](https://arxiv.org/abs/2312.03732)               | `"use_rslora": true`                                      |

  *: Arguments of configuration file


  1. MoE-PEFT supports specific optimized operators for these PEFT methods, which can effectively improve the computing performance during training, evaluation and inference. However, these operators may cause a certain degree of accuracy loss (less than 5%). You can disable the optimized operators by defining the `MOE_PEFT_EVALUATE_MODE` environment variable in advance.
  2. Auxiliary Loss is not currently supported for MoE PEFT methods other than MixLoRA.
  3. You can check detailed arguments of MixLoRA in [TUDB-Labs/MixLoRA](https://github.com/TUDB-Labs/MixLoRA).



  |         | Attention Methods                                            | Name           | Arguments*               |
  |---------|--------------------------------------------------------------|----------------|--------------------------|
  | &check; | [Scaled Dot Product](https://arxiv.org/abs/1706.03762)       | `"eager"`      | `--attn_impl eager`      |
  | &check; | [Flash Attention 2](https://arxiv.org/abs/2307.08691)        | `"flash_attn"` | `--attn_impl flash_attn` |
  | &check; | [Sliding Window Attention](https://arxiv.org/abs/2004.05150) | -              | `--sliding_window`       |

  *: Arguments of `moe_peft.py`

  MoE-PEFT only supports scaled-dot product attention (eager) by default. Additional requirements are necessary for flash attention.

  For flash attention, manual installation of the following dependencies is required:

  ```bash
  pip3 install ninja
  pip3 install flash-attn==2.5.8 --no-build-isolation
  ```

  If any attention method is not specified, flash attention is used if available.



  |         | Quantize Methods      | Arguments*    |
  |---------|-----------------------|---------------|
  | &check; | Full Precision (FP32) | by default    |
  | &check; | Tensor Float 32       | `--tf32`      |
  | &check; | Half Precision (FP16) | `--fp16`      |
  | &check; | Brain Float 16        | `--bf16`      |
  | &check; | 8bit Quantize         | `--load_8bit` |
  | &check; | 4bit Quantize         | `--load_4bit` |

  *: Arguments of `moe_peft.py`

  MoE-PEFT offers support for various model accuracy and quantization methods. By default, MoE-PEFT utilizes full precision (Float32), but users can opt for half precision (Float16) using `--fp16` or BrainFloat16 using `--bf16`. Enabling half precision reduces the model size by half, and for further reduction, quantization methods can be employed.

  Quantization can be activated using `--load_4bit` for 4-bit quantization or `--load_8bit` for 8-bit quantization. However, when only quantization is enabled, MoE-PEFT utilizes Float32 for calculations. To achieve memory savings during training, users can combine quantization and half-precision modes.

  To enable quantization support, please manually install `bitsandbytes`:

  ```bash
  pip3 install bitsandbytes==0.43.1
  ```

  It's crucial to note that regardless of the settings, **LoRA weights are always calculated and stored at full precision**. For maintaining calculation accuracy, MoE-PEFT framework mandates the use of full precision for calculations when accuracy is imperative.

  For users with NVIDIA Ampere or newer GPU architectures, the `--tf32` option can be utilized to enable full-precision calculation acceleration.



  MoE-PEFT relies on **HuggingFace Hub** to download necessary models, datasets, etc. If you cannot access the Internet or need to deploy MoE-PEFT in an offline environment, please refer to the following guide.

  1. Use `git-lfs` manually downloads models and datasets from [HuggingFace Hub](https://huggingface.co).
  2. Set `--data_path` to the local path to datasets when executing `launch.py gen`.
  3. Clone the [evaluate](https://github.com/huggingface/evaluate) code repository locally.
  4. Set environment variable `MOE_PEFT_METRIC_PATH` to the local path to `metrics` folder of evaluate code repository.
  5. Set `--base_model` to the local path to models when executing `launch.py run`.

  Example of (4): `export MOE_PEFT_METRIC_PATH=/path-to-your-git-repo/evaluate/metrics`



   + Quantization with Qwen2 have no effect (same with transformers).
   + Applying quantization with DoRA will result in higher memory and computation cost (same with PEFT).
   + Sliding window attention with generate cache may product abnormal output.



  Please refer to [MoE-PEFT Install Guide](./Install.md).



  You can conveniently utilize MoE-PEFT via `launch.py`. The following example demonstrates a streamlined approach to training a dummy model with MoE-PEFT.

  ```bash

  python launch.py gen --template lora --tasks ./tests/dummy_data.json


  python launch.py run --base_model TinyLlama/TinyLlama_v1.1


  python inference.py \
    --base_model TinyLlama/TinyLlama_v1.1 \
    --template alpaca \
    --lora_weights ./casual_0
  ```

  For further detailed usage information, please refer to the `help` command:

  ```bash
  python launch.py help
  ```



  The `moe_peft.py` code is a starting point for finetuning on various datasets.

  Basic command for finetuning a baseline model on the [Alpaca Cleaned](https://github.com/gururise/AlpacaDataCleaned) dataset:
  ```bash

  python launch.py gen \
    --template lora \
    --tasks yahma/alpaca-cleaned

  python moe_peft.py \
    --base_model meta-llama/Llama-2-7b-hf \
    --config moe_peft.json \
    --bf16
  ```

  You can check the template finetune configuration in [templates](./templates/) folder.

  For further detailed usage information, please use `--help` option:
  ```bash
  python moe_peft.py --help
  ```



  Firstly, ensure that you have installed Docker Engine and NVIDIA Container Toolkit correctly.

  After that, you can launch the container using the following typical command:

  ```
  docker run --gpus all -it --rm mikecovlee/moe_peft
  ```

  You can check all available tags from: [mikecovlee/moe_peft/tags](https://hub.docker.com/r/mikecovlee/moe_peft/tags)

  Please note that this container only provides a proper environment to run MoE-PEFT. The codes of MoE-PEFT are not included.



  This project is licensed under the [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: 83935ded6648cd319f402560e3f33c8815c9caceaff96be9483b748aaf67242e
name: python-moesifdjango-help
arch: noarch
version: 2.3.12
epoch: 0
release: 1
summary: Development documents and examples for moesifdjango
url: https://www.moesif.com/docs/server-integration/django/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moesifdjango-2.3.12-1.src.rpm
location_href: Packages/python-moesifdjango-help-2.3.12-1.noarch.rpm
checksum_type: sha256
description:
  by [Moesif](https://moesif.com), the [API analytics](https://www.moesif.com/features/api-analytics) and [API monetization](https://www.moesif.com/solutions/metered-api-billing) platform.

  [![Built For][ico-built-for]][link-built-for]
  [![Latest Version][ico-version]][link-package]
  [![Language Versions][ico-language]][link-language]
  [![Software License][ico-license]][link-license]
  [![Source Code][ico-source]][link-source]

  Moesif middleware for Django automatically logs incoming and outgoing API calls
  and sends them to [Moesif](https://www.moesif.com) for API analytics and monitoring.

  This SDK uses the Requests library and works for Python versions 2.7 up to 3.10.4.

  > If you're new to Moesif, see [our Getting Started](https://www.moesif.com/docs/) resources to quickly get up and running.


  Before using this middleware, make sure you have the following:

  - [An active Moesif account](https://moesif.com/wrap)
  - [A Moesif Application ID](#get-your-moesif-application-id)


  After you log into [Moesif Portal](https://www.moesif.com/wrap), you can get your Moesif Application ID during the onboarding steps. You can always access the Application ID any time by following these steps from Moesif Portal after logging in:

  1. Select the account icon to bring up the settings menu.
  2. Select **Installation** or **API Keys**.
  3. Copy your Moesif Application ID from the **Collector Application ID** field.
  <img class="lazyload blur-up" src="images/app_id.png" width="700" alt="Accessing the settings menu in Moesif Portal">



  Install with pip:

  ```shell
  pip install moesifdjango
  ```


  See the available [configuration options](#configuration-options) to learn how to configure the middleware for your use case.



  In your [Django settings file](https://docs.djangoproject.com/en/4.0/topics/settings/#default-settings), add `moesifdjango.middleware.moesif_middleware`
  to the [`MIDDLEWARE` array](https://docs.djangoproject.com/en/4.0/topics/http/middleware/#activating-middleware):

  ```python
  MIDDLEWARE = [
      'django.middleware.security.SecurityMiddleware',
      'django.contrib.sessions.middleware.SessionMiddleware',
      'django.middleware.common.CommonMiddleware',
      'django.middleware.csrf.CsrfViewMiddleware',
      'django.contrib.auth.middleware.AuthenticationMiddleware',
      'moesifdjango.middleware.moesif_middleware',
      'django.contrib.messages.middleware.MessageMiddleware',
      'django.middleware.clickjacking.XFrameOptionsMiddleware',
  ]
  ```

  Because of [middleware execution order](https://docs.djangoproject.com/en/4.0/ref/middleware/#middleware-ordering), we highly recommend that you add `moesif_middleweare` _after_ `SessionMiddleware` and `AuthenticationMiddleware`. These Django middleware add useful session data that enables deeper error analysis. On the other hand, if you have other middleware that modifies responses before going out, you may choose to place Moesif middleware before the middleware that modifies responses. This allows Moesif to see the modifications to the response data and see closer to what goes over the wire.



  Django middleware style and setup was refactored in version 1.10. You need need to import the correct version of Moesif middleware depending on your Django version:

  - For Django 1.10 or greater, use `moesifdjango.middleware.moesif_middleware`.
  - For Django 1.9 or older, you need to follow the legacy style for importing middleware and use `moesifdjango.middleware_pre19.MoesifMiddlewarePre19` instead.

  To find your current Django version, you can execute the following command in your terminal:

  ```sh
  python -c "import django; print(django.get_version())"
  ```



  Django 1.10 renamed `MIDDLEWARE_CLASSES` to `MIDDLEWARE.` Therefore, for Django 1.10 or newer, you must [activate your middleware](https://docs.djangoproject.com/en/4.0/topics/http/middleware/#activating-middleware) by adding it to the `MIDDLEWARE` list:

  ```python
  MIDDLEWARE = [
      ...,
      'django.contrib.sessions.middleware.SessionMiddleware',
      'django.middleware.common.CommonMiddleware',
      'django.contrib.auth.middleware.AuthenticationMiddleware',
      'moesifdjango.middleware.moesif_middleware'
      ...
  ]
  ```

  Then add a dictionary `MOESIF_MIDDLEWARE` to your Django settings file:

  ```
  MOESIF_MIDDLEWARE = {
      'APPLICATION_ID': 'YOUR_MOESIF_APPLICATION_ID',
      'LOG_BODY': True,
  }
  ```



  [Activate the middleware](https://docs.djangoproject.com/en/1.8/topics/http/middleware/#activating-middleware) by adding it to the `MIDDLEWARE_CLASSES` list in your Django settings file:

  ```
  MIDDLEWARE_CLASSES = [
      ...,
      'moesifdjango.middleware_pre19.MoesifMiddlewarePre19',
      
  ]
  ```

  Then add a dictionary `MOESIF_MIDDLEWARE` to your Django settings file:
  ```

  MOESIF_MIDDLEWARE = {
      'APPLICATION_ID': 'YOUR_MOESIF_APPLICATION_ID',
      'LOG_BODY': True,
  }
  ```

  The dictionary contains the [configuration options](#configuration-options) for
  the middleware, including your [Moesif Application ID](#get-your-moesif-application-id) that you must specify.


  In addition to your own APIs, you can also start capturing calls out to third party services through by setting the [`CAPTURE_OUTGOING_REQUESTS` option](#capture_outgoing_requests).

  For configuration options specific to capturing outgoing API calls, see [Options For Outgoing API Calls](#options-for-outgoing-api-calls).


  For a general troubleshooting guide that can help you solve common problems, see [Server Troubleshooting Guide](https://www.moesif.com/docs/troubleshooting/server-troubleshooting-guide/).

  Other troubleshooting supports:

  - [FAQ](https://www.moesif.com/docs/faq/)
  - [Moesif support email](mailto:support@moesif.com)


  When using Docker with Ubuntu-based image, events may not be captured if the image fails to find any timezone configuration. To solve this issue, add the following line to your Dockerfile:

  ```
  ENV TZ=UTC
  ```

  Otherwise, you can add `RUN apt-get install tzdata` in the Dockerfile.



  ```
  .
  ├── BUILDING.md
  ├── images/
  ├── LICENSE
  ├── MANIFEST.in
  ├── moesifdjango/
  ├── pull_request_template.md
  ├── README.md
  ├── requirements.txt
  ├── setup.cfg
  ├── setup.py
  └── tests/
  ```


  The following sections describe the available configuration options for this middleware. You have to set these options in a Python dictionary `MOESIF_MIDDLEWARE`. See the [examples](#examples) for better understanding.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
    </tr>
    <tr>
     <td>
      String
     </td>
    </tr>
  </table>

  A string that [identifies your application in Moesif](#get-your-moesif-application-id).


  The following options document the configuration options to use for incoming API calls.

  Several options use request and response as input arguments. These correspond to [Django's request and response objects](https://docs.djangoproject.com/en/1.10/ref/request-response/).


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(request, response)</code>
     </td>
     <td>
      Boolean
     </td>
    </tr>
  </table>

  Optional.

  This function takes Requests [`Request` and `Response` objects](https://requests.readthedocs.io/en/latest/user/advanced/#request-and-response-objects) and returns `True` if you want to skip this particular event.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(request, response)</code>
     </td>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional, but highly recommended.

  This function takes a request and a response and returns a string that represents
  the user ID used by your system.

  Moesif tries to identify users automatically and fetch the username from [`django.http.HttpRequest.user`](https://docs.djangoproject.com/en/1.8/ref/request-response/#django.http.HttpRequest.user). However, if implementation differs, we highly recommend that you accurately provide a
  user ID using this function.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(request, response)</code>
     </td>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional.

  A function that takes a request and a response and returns a string that represents the company ID for this event.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(request, response)</code>
     </td>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional.

  A function that takes a request and a response, and returns a string that represents the session token for this event.

  Similar to [user IDs](#identify_user), Moesif tries to get the session token automatically. However, if you setup differs from the standard, this function can help tying up events together and help you replay the events.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(request, response)</code>
     </td>
     <td>
      Dictionary
     </td>
    </tr>
  </table>

  Optional.

  A function that takes a request and a response and returns a Python dictionary.

  The dictionary must be such that it can be converted into valid JSON. This allows you to associate this event with custom metadata. For example, you may want to save a virtual machine instance ID, a trace ID, or a tenant ID with the request.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      <code>Boolean</code>
     </td>
     <td>
      <code>True</code>
     </td>
    </tr>
  </table>

  Optional.

  Whether to log request and response body to Moesif.

  Set to `False` to remove the HTTP body before sending to Moesif.

  If you want more control over which fields the middleware includes or not, see the next option `MASK_EVENT_MODEL`.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(EventModel)</code>
     </td>
     <td>
      <code>EventModel</code>
     </td>
    </tr>
  </table>

  Optional.

  A function that takes the final Moesif event model and returns an `EventModel` object with desired data removed.

  Use this if you prefer to write your own mask function than uses the string based filter options:

  - `REQUEST_BODY_MASKS`
  - `REQUEST_HEADER_MASKS`
  - `RESPONSE_BODY_MASKS`
  - `RESPONSE_HEADER_MASKS`

  The return value must be a valid `EventModel` required by Moesif data ingestion API. For more information about Moesif event model, see [Moesif Python API documentation](https://www.moesif.com/docs/api?python).


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      <code>int</code>
     </td>
     <td>
      <code>25</code>
     </td>
    </tr>
  </table>

  Optional.

  Specifies the maximum batch size when sending to Moesif.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      <code>int</code>
     </td>
     <td>
      <code>1000_000</code>
     </td>
    </tr>
  </table>

  Optional.

  The maximum number of events to hold in queue before sending to Moesif.

  In case of network issues, the middleware may fail to connect or send event to Moesif. In those cases, the middleware skips adding new to event to queue to prevent memory overflow.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      String
     </td>
     <td>
      <code>authorization</code>
     </td>
    </tr>
  </table>

  Optional.

  A request header field name used to identify the User in Moesif. It also supports a comma separated string. Moesif checks headers in order like `"X-Api-Key,Authorization"`.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      String
     </td>
     <td>
      <code>sub</code>
     </td>
    </tr>
  </table>

  Optional.

  A field name used to parse the user from authorization header in Moesif.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
    </tr>
    <tr>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional.

  A local proxy hostname when sending traffic through secure proxy. Remember to set this field when using secure proxy. For more information, see [Secure Proxy documentation.](https://www.moesif.com/docs/platform/secure-proxy/#2-configure-moesif-sdk).



  The following options apply to outgoing API calls. These are calls you initiate using the Python [Requests](http://docs.python-requests.org/en/master/) library to third parties like Stripe or to your own services.

  Several options use request and response as input arguments. These correspond to the [Requests](http://docs.python-requests.org/en/master/api/) library's request or response objects.

  If you are not using Django, you can import [`moesifpythonrequest`](https://github.com/Moesif/moesifpythonrequest) directly.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      Boolean
     </td>
     <td>
      <code>False</code>
     </td>
    </tr>
  </table>

  Set to `True` to capture all outgoing API calls.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(req, res)</code>
     </td>
     <td>
      Dictionary
     </td>
    </tr>
  </table>

  Optional.

  A function that enables you to return custom metadata associated with the logged API calls.

  Takes in the [Requests](http://docs.python-requests.org/en/master/api/) request and response objects as arguments.

  We recommend that you implement a function that
  returns a dictionary containing your custom metadata. The dictionary must be a valid one that can be encoded into JSON. For example, you may want to save a virtual machine instance ID, a trace ID, or a resource ID with the request.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(req, res)</code>
     </td>
     <td>
      Boolean
     </td>
    </tr>
  </table>

  Optional.

  A function that takes a [Requests](http://docs.python-requests.org/en/master/api/) request and response objects,
  and returns `True` if you want to skip this particular event.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(req, res)</code>
     </td>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional, but highly recommended.

  A function that takes [Requests](http://docs.python-requests.org/en/master/api/) request and response objects, and returns a string that represents the user ID used by your system.

  While Moesif tries to identify users automatically, different frameworks and your implementation might vary. So we highly recommend that you accurately provide a
  user ID using this function.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(req, res)</code>
     </td>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional.

  A function that takes [Requests](http://docs.python-requests.org/en/master/api/) request and response objects and returns a string that represents the company ID for this event.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Parameters
     </th>
     <th scope="col">
      Return type
     </th>
    </tr>
    <tr>
     <td>
      Function
     </td>
     <td>
      <code>(req, res)</code>
     </td>
     <td>
      String
     </td>
    </tr>
  </table>

  Optional.

  A function that takes [Requests](http://docs.python-requests.org/en/master/api/) request and response objects, and returns a string that corresponds to the session token for this event.

  Similar to [user IDs](#identify_user_outgoing), Moesif tries to get the session token automatically. However, if you setup differs from the standard, this function can help tying up events together and help you replay the events.



  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
     <th scope="col">
      Default
     </th>
    </tr>
    <tr>
     <td>
      Boolean
     </td>
     <td>
      <code>True</code>
     </td>
    </tr>
  </table>

  Optional.

  Set to `False` to remove logging request and response body.


  <table>
    <tr>
     <th scope="col">
      Data type
     </th>
    </tr>
    <tr>
     <td>
      Boolean
     </td>
    </tr>
  </table>

  Optional.

  Set to `True` to print internal log messages for debugging SDK integration issues.


  See the [Moesif Django Example](https://github.com/Moesif/moesifdjangoexample) for a complete Django application that uses this middleware.

  The following shows a sample Django settings file with different configuration options.

  ```python
  def identify_user(req, res):
      
      if req.user and req.user.is_authenticated:
          return req.user.username
      else:
          return None

  def identify_company(req, res):
      
      return "67890"

  def should_skip(req, res):
      
      return "health/probe" in req.path

  def get_token(req, res):
      
      
      return "XXXXXXXXXXXXXX"

  def mask_event(eventmodel):
      
      if 'password' in eventmodel.response.body:
          eventmodel.response.body['password'] = None
      return eventmodel

  def get_metadata(req, res):
      return {
          'datacenter': 'westus',
          'deployment_version': 'v1.2.3',
      }


  MOESIF_MIDDLEWARE = {
      'APPLICATION_ID': 'Your application id',
      'LOCAL_DEBUG': False,
      'LOG_BODY': True,
      'IDENTIFY_USER': identify_user,
      'IDENTIFY_COMPANY': identify_company,
      'GET_SESSION_TOKEN': get_token,
      'SKIP': should_skip,
      'MASK_EVENT_MODEL': mask_event,
      'GET_METADATA': get_metadata,
  }
  ```

  The following examples demonstrate how to add and update customer information using the middleware.


  To create or update a [user](https://www.moesif.com/docs/getting-started/users/) profile in Moesif, use the `update_user()` method.

  ```python
  middleware = MoesifMiddleware(None)





  user = {
    'user_id': '12345',
    'company_id': '67890', # If set, associate user with a company object
    'campaign': {
      'utm_source': 'google',
      'utm_medium': 'cpc',
      'utm_campaign': 'adwords',
      'utm_term': 'api+tooling',
      'utm_content': 'landing'
    },
    'metadata': {
      'email': 'john@acmeinc.com',
      'first_name': 'John',
      'last_name': 'Doe',
      'title': 'Software Engineer',
      'sales_info': {
          'stage': 'Customer',
          'lifetime_value': 24000,
          'account_owner': 'mary@contoso.com'
      },
    }
  }

  update_user = middleware.update_user(user)
  ```

  The `metadata` field can contain any customer demographic or other info you want to store. Moesif only requires the `user_id` field. This method is a convenient helper that calls the Moesif API library.

  For more information, see [Moesif Python API reference](https://www.moesif.com/docs/api?python#update-a-user).


  To update a list of [users](https://www.moesif.com/docs/getting-started/users/) in one batch, use the `update_users_batch()` method.

  ```python
  middleware = MoesifMiddleware(None)

  userA = {
    'user_id': '12345',
    'company_id': '67890', # If set, associate user with a company object
    'metadata': {
      'email': 'john@acmeinc.com',
      'first_name': 'John',
      'last_name': 'Doe',
      'title': 'Software Engineer',
      'sales_info': {
          'stage': 'Customer',
          'lifetime_value': 24000,
          'account_owner': 'mary@contoso.com'
      },
    }
  }

  userB = {
    'user_id': '54321',
    'company_id': '67890', # If set, associate user with a company object
    'metadata': {
      'email': 'mary@acmeinc.com',
      'first_name': 'Mary',
      'last_name': 'Jane',
      'title': 'Software Engineer',
      'sales_info': {
          'stage': 'Customer',
          'lifetime_value': 48000,
          'account_owner': 'mary@contoso.com'
      },
    }
  }
  update_users = middleware.update_users_batch([userA, userB])
  ```

  The `metadata` field can contain any customer demographic or other info you want to store. Moesif only requires the `user_id` field. This method is a convenient helper that calls the Moesif API library.

  For more information, see [Moesif Python API reference](https://www.moesif.com/docs/api?python#update-users-in-batch).


  To update a single [company](https://www.moesif.com/docs/getting-started/companies/), use the `update_company()` method.

  ```python
  middleware = MoesifMiddleware(None)





  company = {
    'company_id': '67890',
    'company_domain': 'acmeinc.com', # If domain is set, Moesif will enrich your profiles with publicly available info
    'campaign': {
      'utm_source': 'google',
      'utm_medium': 'cpc',
      'utm_campaign': 'adwords',
      'utm_term': 'api+tooling',
      'utm_content': 'landing'
    },
    'metadata': {
      'org_name': 'Acme, Inc',
      'plan_name': 'Free',
      'deal_stage': 'Lead',
      'mrr': 24000,
      'demographics': {
          'alexa_ranking': 500000,
          'employee_count': 47
      },
    }
  }

  update_company = middleware.update_company(company)
  ```

  The `metadata` field can contain any company demographic or other info you want to store. Moesif only requires the `company_id` field. This method is a convenient helper that calls the Moesif API library.

  For more information, see [Moesif Python API reference](https://www.moesif.com/docs/api?python#update-a-company).


  To update a list of [companies](https://www.moesif.com/docs/getting-started/companies/) in one batch, use the `update_companies_batch()` method.

  ```python
  middleware = MoesifMiddleware(None)

  companyA = {
    'company_id': '67890',
    'company_domain': 'acmeinc.com', # If domain is set, Moesif will enrich your profiles with publicly available info
    'metadata': {
      'org_name': 'Acme, Inc',
      'plan_name': 'Free',
      'deal_stage': 'Lead',
      'mrr': 24000,
      'demographics': {
          'alexa_ranking': 500000,
          'employee_count': 47
      },
    }
  }

  companyB = {
    'company_id': '09876',
    'company_domain': 'contoso.com', # If domain is set, Moesif will enrich your profiles with publicly available info
    'metadata': {
      'org_name': 'Contoso, Inc',
      'plan_name': 'Free',
      'deal_stage': 'Lead',
      'mrr': 48000,
      'demographics': {
          'alexa_ranking': 500000,
          'employee_count': 53
      },
    }
  }

  update_companies = middleware.update_companies_batch([userA, userB])
  ```

  The `metadata` field can contain any company demographic or other info you want to store. Moesif only requires the `company_id` field. This method is a convenient helper that calls the Moesif API library.

  For more information, see [Moesif Python API reference](https://www.moesif.com/docs/api?python#update-companies-in-batch).




  To create or update a subscription in Moesif, use the `update_subscription` method.

  ```python
  middleware = MoesifMiddleware(None)



  subscription = {
    'subscription_id': 'sub_67890',
    'company_id': '3456',
    'status': 'active'
    'metadata': {
      'plan_name': 'Pro',
      'signup_date': '2020-09-09',
      'expiration_date': '2021-09-09',
      'payment_method': 'credit_card',
      'mrr': 12000,
      'currency': 'USD'
    }
  }

  update_subscription = middleware.update_subscription(subscription)
  ```

  The `metadata` field can store any subscription-related information. Moesif only requires the the following fields:

  - `subscription_id`
  - `company_id`
  - `status`

  This method is a convenient helper that calls the Moesif API library.

  For more information, see [Moesif Python API reference](https://www.moesif.com/docs/api?python#update-a-subscription).


  To update a list of subscriptions in one batch, use the `update_subscriptions_batch` method.

  ```python
  middleware = MoesifMiddleware(None)

  subscriptionA = {
    'subscription_id': 'sub_67890',
    'company_id': '3456',
    'status': 'active'
    'metadata': {
      'plan_name': 'Pro',
      'signup_date': '2020-09-09',
      'expiration_date': '2021-09-09',
      'payment_method': 'credit_card',
      'mrr': 12000,
      'currency': 'USD'
    }
  }

  subscriptionB = {
    'subscription_id': 'sub_54321',
    'company_id': '6789',
    'status': 'active'
    'metadata': {
      'plan_name': 'Enterprise',
      'signup_date': '2020-10-01',
      'expiration_date': '2021-10-01',
      'payment_method': 'paypal',
      'mrr': 24000,
      'currency': 'USD'
    }
  }

  update_subscriptions = middleware.update_subscriptions_batch([subscriptionA, subscriptionB])
  ```

  The `metadata` field can store any subscription-related information. Moesif only requires the the following fields:

  - `subscription_id`
  - `company_id`
  - `status`

  This method is a convenient helper that calls the Moesif API library.

  For more information, see [Moesif Python API reference](https://www.moesif.com/docs/api?python#update-subscriptions-in-batch).



  Moesif has validated this middleware against the following combinations of Python and Django versions:

  | Python        | Django     |
  | ------------  | -------    |
  | Python 2.7    | 1.11.22    |
  | Python 2.7    | 1.11.22    |
  | Python 2.7    | 1.9        |
  | Python 3.4.5  | 1.11.22    |
  | Python 3.4.5  | 1.11.22    |
  | Python 3.4.5  | 1.9        |
  | Python 3.6.4  | 1.11.22    |
  | Python 3.6.4  | 1.11.22    |
  | Python 3.6.4  | 1.9        |
  | Python 3.10.4 | 3.2.13 LTS |
  | Python 3.10.4 | 4.0.5      |


  1. Manually clone this repository.
  2. From your terminal, navigate to the root directory of the middleware.
  3. Run `pip install Django` and then run `pip install moesifdjango`.
  4. Add your [Moesif Application ID](#get-your-moesif-application-id) to `tests/settings.py`.
  5. From terminal, navigate to the root directory of the middleware tests `tests/`.

     a. Run `python manage.py test` if you are using Django 1.10 or newer.

     b. Run `python manage.py test middleware_pre19_tests` if you are using Django 1.9 or older.



  On MacOS, with `gunicorn`, it is possible to encounter this error: "in progress in another thread when fork() was called". Solution is to add `--preload` option when launching `gunicorn` like below.

  ```bash
  gunicorn myapp.wsgi:application --bind 127.0.0.1:8000 --preload
  ```



  Explore other integration options from Moesif:

  - [Server integration options documentation](https://www.moesif.com/docs/server-integration//)
  - [Client integration options documentation](https://www.moesif.com/docs/client-integration/)

  [ico-built-for]: https://img.shields.io/badge/built%20for-django-blue.svg
  [ico-version]: https://img.shields.io/pypi/v/moesifdjango.svg
  [ico-language]: https://img.shields.io/pypi/pyversions/moesifdjango.svg
  [ico-license]: https://img.shields.io/badge/License-Apache%202.0-green.svg
  [ico-source]: https://img.shields.io/github/last-commit/moesif/moesifdjango.svg?style=social

  [link-built-for]: https://www.djangoproject.com/
  [link-package]: https://pypi.python.org/pypi/moesifdjango
  [link-language]: https://pypi.python.org/pypi/moesifdjango
  [link-license]: https://raw.githubusercontent.com/Moesif/moesifdjango/master/LICENSE
  [link-source]: https://github.com/Moesif/moesifdjango


pkgId: 551894c95b6466a32dd9cc310df701d26e7a348ea1c3914b90fa0ca1aa4af8aa
name: python-moirai-engine-help
arch: noarch
version: 0.0.25
epoch: 0
release: 1
summary: Development documents and examples for moirai-engine
url: https://pypi.org/project/moirai-engine/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moirai-engine-0.0.25-1.src.rpm
location_href: Packages/python-moirai-engine-help-0.0.25-1.noarch.rpm
checksum_type: sha256
description:
  <!-- TOC -->
  - [moirai-engine](#moirai-engine)
    - [Table of Contents](#table-of-contents)
    - [Installation](#installation)
    - [Usage](#usage)
      - [Basic Example](#basic-example)
      - [Advanced Example](#advanced-example)
    - [About](#about)
    - [License](#license)
  <!-- /TOC -->
  > **NOTE:** This doc is still in progress. for now it was generated by AI (sorry).

  ```console
  pip install moirai-engine
  ```


  Here is a basic example of how to use the `moirai-engine` library to create and run a simple job:
  ```python
  import time
  from moirai_engine.core.engine import Engine
  from moirai_engine.utils.samples import hello_world

  engine = Engine()
  engine.start()

  job = hello_world()

  engine.add_job(job)

  time.sleep(5)

  engine.stop()
  ```

  Here is an advanced example that includes real-time notifications and job cancellation:
  ```python
  import asyncio
  from moirai_engine.core.engine import Engine
  from moirai_engine.utils.samples import hello_world

  async def notification_listener(notification):
      print(f"Received notification: {notification}")
  async def main():
      engine = Engine(max_workers=4, listener=notification_listener)
      await engine.start()
      
      await engine.add_job(hello_world(), notification_listener)
      
      await asyncio.sleep(2)
      await engine.stop()
  if __name__ == "__main__":
      asyncio.run(main())
  ```

  `moirai-engine` is the engine that powers [Ananke](https://github.com/fcrozetta/ananke), but it was planned to be used as a processing engine. This project is still in progress, and features like task registry and autodiscover are still in development.

  MIT License


pkgId: 0ccb4177459a19c59e52621448a2c516590c820635f451098b3e13782ca08d03
name: python-mokkari-help
arch: noarch
version: 3.5.0
epoch: 0
release: 1
summary: Development documents and examples for mokkari
url: https://github.com/Metron-Project/mokkari
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mokkari-3.5.0-1.src.rpm
location_href: Packages/python-mokkari-help-3.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/mokkari.svg)](https://pypi.org/project/mokkari/)
  [![PyPI - Python](https://img.shields.io/pypi/pyversions/mokkari.svg)](https://pypi.org/project/mokkari/)
  [![Ruff](https://img.shields.io/badge/Linter-Ruff-informational)](https://github.com/charliermarsh/ruff)
  [![Pre-Commit](https://img.shields.io/badge/Pre--Commit-Enabled-informational?logo=pre-commit)](https://github.com/pre-commit/pre-commit)

  A python wrapper for the [Metron Comic Book Database](https://metron.cloud) API.



  ```bash
  pip install mokkari
  ```



  ```python
  import mokkari


  from config import username, password

  m = mokkari.api(username, password)


  this_week = m.issues_list({"store_date_range_after": "2021-06-07", "store_date_range_before": "2021-06-13", "publisher_name": "marvel"})


  for i in this_week:
      print(f"{i.id} {i.issue_name}")


      asm_68 = m.issue(31660)


  print(asm_68.desc)
  ```



  [Read the project documentation](https://mokkari.readthedocs.io/en/stable/?badge=latest)



  Please use the
  [GitHub issue tracker](https://github.com/Metron-Project/mokkari/issues) to
  submit bugs or request features.


pkgId: 36b3abd4399fab89db30c051b375e52c4f0a924d91050f9bb7eb779d240aae0a
name: python-moku-help
arch: noarch
version: 3.3.2
epoch: 0
release: 1
summary: Development documents and examples for moku
url: https://liquidinstruments.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moku-3.3.2-1.src.rpm
location_href: Packages/python-moku-help-3.3.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python library for the command, control and monitoring of the [Liquid Instruments Moku:Go](http://www.liquidinstruments.com).
  API documentation can be found at [ReadTheDocs](http://moku.readthedocs.org).




  - [Python](https://www.python.org) installed.  We support Python >= **3.5**.
  - Zeroconf to browse for Moku's on network
  - Your Moku connected to the same network as your computer.
  - Internet access.


  Open a command-line terminal and type

      pip install --upgrade moku

  If you wish to build and train models for the Moku Neural Network instrument, install optional machine learning dependencies with

      pip install moku[neuralnetwork]

  The IP address of your Moku:Go device can be found with

      moku list


  You are now ready to control your Moku:Go using Python! You can find a few example scripts in the **examples/** folder.
  Here is a basic example of how to connect to a Moku:Go, deploy the Oscilloscope and fetch a single hi-res data trace. Open python and run the following code

  ```python
  from moku.instruments import Oscilloscope



  i = Oscilloscope('192.168.###.###', force_connect=False)

  try:
      
      i.set_timebase(-1, 1)

      
      
      data = i.get_data()
      print(data['ch1'], data['ch2'], data['time'])
  except Exception as e:
      print(f'Exception occurred: {e}')
  finally:
      i.relinquish_ownership()
  ```




  Ensure moku has been successfully installed in your Python distrubution by open a python shell and running

      import moku

  No error indicates a successful install.

  You may need to add python binaries to your PATH.  This varies with operating system and python version but as an example

      export PATH=$PATH:/home/user/.local/bin


  Make sure you are running the version of Python you installed moku to.  Often a system will have multiple Python installations. Try substituting `pip` with `python -m pip` in the installation.
  If you installed moku inside an Environment (i.e. via virtualenv or conda-env), ensure that Environment is activated. You can check that moku is installed in your currently running environment using

      (myenv)$ pip list



  Please report issues at https://www.liquidinstruments.com/support/contact/


pkgId: bf62011119ca238cdf87a810fbd83a7be5413e002a7ff1326ab323085a9c305a
name: python-molgenis-emx2-staging-migrator-help
arch: noarch
version: 11.40.3
epoch: 0
release: 1
summary: Development documents and examples for molgenis-emx2-staging-migrator
url: https://pypi.org/project/molgenis-emx2-staging-migrator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-molgenis-emx2-staging-migrator-11.40.3-1.src.rpm
location_href: Packages/python-molgenis-emx2-staging-migrator-help-11.40.3-1.noarch.rpm
checksum_type: sha256
description:
  ```console
  pip install molgenis-emx2-staging-migrator
  ```



  Within your Python project import the class StagingMigrator and use it as a context manager

  ```py
  from molgenis_emx2_staging_migrator import StagingMigrator

  token = '...'

  with StagingMigrator('https://example.molgeniscloud.org', token=token) as migrator:

      
      print(migrator.status)

      
      migrator.set_staging_area('StagingExample')
      migrator.set_catalogue('catalogue')

      
      migrator.migrate()


  ```








  ```console
  (venv) $ python -m build

  (venv) $ pip install dist/molgenis-emx2-staging_migrator*.whl
  ```


pkgId: 711d9d877398bb4c1a46a90ed2191b9f49aa375608871e728fc8ab7f506397ba
name: python-momo-morphological-modeling-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for momo-morphological-modeling
url: https://github.com/danylevych/MoMo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-momo-morphological-modeling-1.2.0-1.src.rpm
location_href: Packages/python-momo-morphological-modeling-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  The `model` module contains the main classes for the morphological modeling. The main class is `MoMoModel` which is used to create a morphological model and to perform the morphological analysis.

  The `MoMoModel` class represents a **Multi-Object Multi-System Model** designed to manage multiple system models and a prototype for similarity calculations. It integrates the `Prototype` and `MultiSystemModel` classes, enabling users to perform operations on system models and calculate similarity measures between them.

  - Supports initialization with multiple system models and an optional prototype.
  - Automatically generates a prototype based on the system models if not provided.
  - Allows for similarity measure calculations between the prototype and combinations of system models.


pkgId: d4e41fa2bdf72a5b8e89db3c842878338e3a057a3b0f0a82305fa7b4769e75b3
name: python-monai-weekly-help
arch: noarch
version: 1.5.dev2450
epoch: 0
release: 1
summary: Development documents and examples for monai-weekly
url: https://monai.io/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monai-weekly-1.5.dev2450-1.src.rpm
location_href: Packages/python-monai-weekly-help-1.5.dev2450-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/Project-MONAI/MONAI/dev/docs/images/MONAI-logo-color.png" width="50%" alt='project-monai'>
  </p>

  **M**edical **O**pen **N**etwork for **AI**

  ![Supported Python versions](https://raw.githubusercontent.com/Project-MONAI/MONAI/dev/docs/images/python.svg)
  [![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
  [![PyPI version](https://badge.fury.io/py/monai.svg)](https://badge.fury.io/py/monai)
  [![docker](https://img.shields.io/badge/docker-pull-green.svg?logo=docker&logoColor=white)](https://hub.docker.com/r/projectmonai/monai)
  [![conda](https://img.shields.io/conda/vn/conda-forge/monai?color=green)](https://anaconda.org/conda-forge/monai)

  [![premerge](https://github.com/Project-MONAI/MONAI/actions/workflows/pythonapp.yml/badge.svg?branch=dev)](https://github.com/Project-MONAI/MONAI/actions/workflows/pythonapp.yml)
  [![postmerge](https://img.shields.io/github/checks-status/project-monai/monai/dev?label=postmerge)](https://github.com/Project-MONAI/MONAI/actions?query=branch%3Adev)
  [![Documentation Status](https://readthedocs.org/projects/monai/badge/?version=latest)](https://docs.monai.io/en/latest/)
  [![codecov](https://codecov.io/gh/Project-MONAI/MONAI/branch/dev/graph/badge.svg?token=6FTC7U1JJ4)](https://codecov.io/gh/Project-MONAI/MONAI)
  [![monai Downloads Last Month](https://assets.piptrends.com/get-last-month-downloads-badge/monai.svg 'monai Downloads Last Month by pip Trends')](https://piptrends.com/package/monai)

  MONAI is a [PyTorch](https://pytorch.org/)-based, [open-source](https://github.com/Project-MONAI/MONAI/blob/dev/LICENSE) framework for deep learning in healthcare imaging, part of the [PyTorch Ecosystem](https://pytorch.org/ecosystem/).
  Its ambitions are as follows:
  - Developing a community of academic, industrial and clinical researchers collaborating on a common foundation;
  - Creating state-of-the-art, end-to-end training workflows for healthcare imaging;
  - Providing researchers with the optimized and standardized way to create and evaluate deep learning models.



  > _Please see [the technical highlights](https://docs.monai.io/en/latest/highlights.html) and [What's New](https://docs.monai.io/en/latest/whatsnew.html) of the milestone releases._

  - flexible pre-processing for multi-dimensional medical imaging data;
  - compositional & portable APIs for ease of integration in existing workflows;
  - domain-specific implementations for networks, losses, evaluation metrics and more;
  - customizable design for varying user expertise;
  - multi-GPU multi-node data parallelism support.




  To install [the current release](https://pypi.org/project/monai/), you can simply run:

  ```bash
  pip install monai
  ```

  Please refer to [the installation guide](https://docs.monai.io/en/latest/installation.html) for other installation options.



  [MedNIST demo](https://colab.research.google.com/drive/1wy8XUSnNWlhDNazFdvGBHLfdkGvOHBKe) and [MONAI for PyTorch Users](https://colab.research.google.com/drive/1boqy7ENpKrqaJoxFlbHIBnIODAs1Ih1T) are available on Colab.

  Examples and notebook tutorials are located at [Project-MONAI/tutorials](https://github.com/Project-MONAI/tutorials).

  Technical documentation is available at [docs.monai.io](https://docs.monai.io).



  If you have used MONAI in your research, please cite us! The citation can be exported from: https://arxiv.org/abs/2211.02701.


  [The MONAI Model Zoo](https://github.com/Project-MONAI/model-zoo) is a place for researchers and data scientists to share the latest and great models from the community.
  Utilizing [the MONAI Bundle format](https://docs.monai.io/en/latest/bundle_intro.html) makes it easy to [get started](https://github.com/Project-MONAI/tutorials/tree/main/model_zoo) building workflows with MONAI.


  For guidance on making a contribution to MONAI, see the [contributing guidelines](https://github.com/Project-MONAI/MONAI/blob/dev/CONTRIBUTING.md).


  Join the conversation on Twitter/X [@ProjectMONAI](https://twitter.com/ProjectMONAI) or join our [Slack channel](https://forms.gle/QTxJq3hFictp31UM9).

  Ask and answer questions over on [MONAI's GitHub Discussions tab](https://github.com/Project-MONAI/MONAI/discussions).


  - Website: https://monai.io/
  - API documentation (milestone): https://docs.monai.io/
  - API documentation (latest dev): https://docs.monai.io/en/latest/
  - Code: https://github.com/Project-MONAI/MONAI
  - Project tracker: https://github.com/Project-MONAI/MONAI/projects
  - Issue tracker: https://github.com/Project-MONAI/MONAI/issues
  - Wiki: https://github.com/Project-MONAI/MONAI/wiki
  - Test status: https://github.com/Project-MONAI/MONAI/actions
  - PyPI package: https://pypi.org/project/monai/
  - conda-forge: https://anaconda.org/conda-forge/monai
  - Weekly previews: https://pypi.org/project/monai-weekly/
  - Docker Hub: https://hub.docker.com/r/projectmonai/monai


pkgId: 4e5857f4fe8f2a5ad9b55b9edc7b721113d2c0ea57127316734184a3295815cb
name: python-monday-client-help
arch: noarch
version: 0.1.61
epoch: 0
release: 1
summary: Development documents and examples for monday-client
url: https://github.com/LeetCyberSecurity/monday-client
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monday-client-0.1.61-1.src.rpm
location_href: Packages/python-monday-client-help-0.1.61-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/monday-client/badge/?version=latest)](https://monday-client.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/monday-client.svg)](https://badge.fury.io/py/monday-client)
  [![Python Versions](https://img.shields.io/pypi/pyversions/monday-client.svg)](https://pypi.org/project/monday-client/)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![GitHub issues](https://img.shields.io/github/issues/LeetCyberSecurity/monday-client.svg)](https://github.com/LeetCyberSecurity/monday-client/issues)
  [![GitHub last commit](https://img.shields.io/github/last-commit/LeetCyberSecurity/monday-client.svg)](https://github.com/LeetCyberSecurity/monday-client/commits/main)

  This Python library provides an **asynchronous** client to interact with the [monday.com API](https://developer.monday.com/api-reference/reference/about-the-api-reference).



  For detailed documentation, visit the [official documentation site](https://monday-client.readthedocs.io).



  - **Asynchronous API calls** using `asyncio` and `aiohttp` for efficient I/O operations.
  - **Automatic handling of API rate limits and query limits** following monday.com's rate limit policies.
  - **Built-in retry logic** for handling rate limit exceptions, ensuring smooth operation without manual intervention.
  - **Easy-to-use methods** for common monday.com operations.
  - **Fully customizable requests** with all monday.com method arguments and fields available to the user.



  ```bash
  pip install monday-client
  ```



  ```python
  import asyncio

  from monday import MondayClient

  async def main():
      monday_client = MondayClient(api_key='your_api_key_here')
      boards = await monday_client.boards.query(board_ids=[987654321, 876543210])
      items = await monday_client.items.query(item_ids=[123456789, 123456780])

  asyncio.run(main())
  ```






  All methods provided by the `MondayClient` are asynchronous and should be awaited. This allows for efficient concurrent execution of API calls.



  The client automatically handles rate limiting in compliance with monday.com's API policies. When a rate limit is reached, the client will wait for the specified reset time before retrying the request. This ensures that your application doesn't need to manually handle rate limit exceptions and can operate smoothly.



  Custom exceptions are defined for handling specific error cases:

  - `MondayAPIError`: Raised when an error occurs during API communication with monday.com.
  - `PaginationError`: Raised when item pagination fails during a request.
  - `QueryFormatError`: Raised when there is a query formatting error.
  - `ComplexityLimitExceeded`: Raised when the complexity limit and max retries are exceeded.
  - `MutationLimitExceeded`: Raised when the mutation limit and max retries are exceeded.



  The client uses a logger named `monday_client` for all logging operations. By default, a `NullHandler` is added to suppress logging output. To enable logging, you can configure the logger in your application:

  ```python
  import logging

  logger = logging.getLogger('monday_client')
  logger.setLevel(logging.INFO)
  handler = logging.StreamHandler()
  handler.setFormatter(logging.Formatter('s - s - s - s'))
  logger.addHandler(handler)
  ```

  Or update an already existing logging config:
  ```python
  import logging.config

  logging_config = config['logging']

  logging_config['loggers'].update({
      'monday_client': {
          'handlers': ['file', 'console'],  # Use the same handlers as your main logger
          'level': 'INFO',  # Set appropriate level
          'propagate': False
      }
  })

  logging.config.dictConfig(logging_config)
  logger = logging.getLogger(__name__)
  ```



  This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](https://github.com/LeetCyberSecurity/monday-client/blob/main/LICENSE) file for details.


pkgId: 5af1eaca3eaedb4052737f39a246f4ad6291647f2ed78f828596029f14f3ca0b
name: python-mongoserializer-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mongoserializer
url: https://github.com/ahmadekhalili/onetomultipleimage
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mongoserializer-1.0.0-1.src.rpm
location_href: Packages/python-mongoserializer-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  mongoserializer is a Django REST package that introduces one of the best simple practices for interacting with MongoDB while using pymongo and Django REST Framework. it supports complex nested fields singular/list during the update and create phases. for django fields (ModelSerializer) it supports add operation by id in creation and update phase. for update phase only main fields (not nested). [see example 1](#example-1-creation).

  Whole workflow:
  ![Imgur](https://i.imgur.com/m13ssNC.jpg)



  1. Run: ``` pip install mongoserializer[jalali]```

  To install mongoserializer with Jalali date support, add the ```[jalali]``` part.


  &nbsp;


  **MongoSerializer** is used only in the **writing** phase to write data in MongoDB, in a nice and clean format.
  for **reading** phase it's recommended using separate serializer like [check here](#reading-phase). conflicts may occur when using both of read/write in same serializer [here](#read-write-conflicts-in-a-serializer).



  - **_id**:
    Used in updating. Assign the MongoDB document's `_id`  to update the document.

  - **data**:
    data for create/update the document in the MongoDB.

  - **many**:
    single dict or list of data like `many` in DRF serializer

  - **request**:
    Optional. If your implementation requires 'request' (for validation, etc.), you can pass and use it like **self.request** inside your serializer.
  or use **self.context['request']** in any subclass of the class to access the original request (described in example 2 below).

  - **partial**:
    Required to be True in updating.



  - **is_valid(raise_exception=False)**:
    Same as DRF is_valid(). returns boolean (True or False)

  - **save(**kwargs)**:
    Create/Ppdate the document. **kwargs are additional data if want to save in the document.

  - **Meta.model:
    Used to specify the collection to save. see below example.

  - **serialize_and_filter(validated_data)**:
    Convert `validated_data` to a serialized format ready to save in MongoDB. You can call **serialize_and_filter()** to directly save validated data to MongoDB.

  **Example 1 (creation)**:
  ```python
  from mongoserializer.serializer import MongoSerializer
  from mongoserializer.methods import ResponseMongo

  mongo_db = pymongo.MongoClient("mongodb://localhost:27017/")['my_db']


  class UserNameSerializer(serializers.ModelSerializer):
      class Meta:
          model = User
          fields = ['id', 'username']


  class CommentSerializer(MongoSerializer):
      content = serializers.CharField(max_length=255)


  class PostMongoSerializer(MongoSerializer):
      title = serializers.CharField(max_length=255)
      author = UserNameSerializer(required=False)
      comment = CommentSerializer(required=False)

      class Meta:
          model = mongo_db.file

  serializer = PostMongoSerializer(data={"title": 'Post1', 'author': 1, 'comment': {'content': 'comment 1'}}, request=request)
  if serializer.is_valid():
      data = serializer.save()
      return ResponseMongo(data)
  return ResponseMongo(serializer.errors)
  ```

  `data` returned from **.save()** and saved in MongoDB:
  ```python
  {'_id': ObjectId('6760ea0f4c1a2508d8aa5c08'), 'title': 'Post1', 'author': {'id': 1, 'username': 'akh'}, 'comment': {'_id': ObjectId('6760ea0f4c1a2508d8aa5c09'), 'content': 'comment 1'}}
  ```

  In more practical example 2 we have used `TimestampField` provided by the package and customizing 'to_internal_value' method for more real world use cases.
  **Example 2 (creation)**:
  ```python
  from mongoserializer.serializer import MongoSerializer
  from mongoserializer.fields import TimestampField
  from mongoserializer.methods import ResponseMongo, MongoUniqueValidator

  mongo_db = pymongo.MongoClient("mongodb://localhost:27017/")['my_db']


  class BlogMongoSerializer(MongoSerializer):
      title = serializers.CharField(validators=[MongoUniqueValidator(mongo_db.blog, 'title')], max_length=255)
      slug = serializers.SlugField(required=False)  # Slug generates from title (in to_internal_value)
      published_date = TimestampField(auto_now_add=True, required=False)
      updated = TimestampField(auto_now=True, required=False)
      visible = serializers.BooleanField(default=True)
      author = UserNameSerializer(required=False)

      class Meta:
          model = mongo_db.file

      def to_internal_value(self, data):  # This method fills validated_data directly, after calling is_valid()
          if not data.get('slug') and data.get('title'):
              data['slug'] = slugify(data['title'], allow_unicode=True)
          internal_value = super().to_internal_value(data)

          if self.request:   # if you have pass request kwargs (like BlogMongoSerializer(..., request=reqeust))
              if self.request.user:
                  internal_value['author'] = self.request.user
              else:
                  raise ValidationError({'author': 'Please login to fill blog.author'})
          elif data.get('author'):  # otherwise author's id should provide explicitly in request.data
              internal_value['author'] = get_object_or_404(User, id=data['author'])
          else:
              raise ValidationError({'author': "Please login and pass 'request' parameter or add user's id manually"})
          return internal_value

  mongo_db = pymongo.MongoClient("mongodb://localhost:27017/")['my_db']
  serializer = BlogMongoSerializer(data={"title": 'Hello', 'brief_description': 'about world'}, request=request)
  if serializer.is_valid():
      data = serializer.save()
      return ResponseMongo(data)
  ```

  `validated_data` look like:
  ```python
  {'title': 'Hello', 'slug': 'hello', 'published_date': datetime.datetime(2024, 5, 28, 9, 36, 54, 970462), 'updated': datetime.datetime(2024, 5, 28, 9, 36, 54, 970462), 'brief_description': 'about world', 'visible': True, 'author': <SimpleLazyObject: <User: user1>>}
  ```
  while we only input **'title'** and **'brief_description'**, the following keys are additionally assigned to validated_data based on our setup:
  - **'published_date'** (because of `auto_now_add` argument)
  - **'updated'** (because of `auto_now` argument)
  - **'slug'** (generates inside `to_internal_value` based on 'title')
  - **'visible'** (default=True)
  - **'user'** (assigned inside `to_internal_value`)

  `data` returned from **.save()** is serialized version of `validated_data` and looks like:
  ```python
  {"title": "Hello", "slug": "hello", "published_date": 1716878401, "updated": 1716878401, "brief_description": "about world", "visible": true, "author": {"id": 1, "url": "/users/profile/admin/1/", "user_name": "user1"}, "_id": ObjectId("66557c4188cc1acc1d1e0334")}
  ```
  **Note**: `ResponseMongo` is similar to REST Framework's `Response`, but it converts any nested **ObjectId** to it's str, so it's recommended to use it instead of `Response`.


  &nbsp;
  **Example 3 (updating)**:
  ```python
  serializer = BlogMongoSerializer(_id='66557c4188cc1acc1d1e0334', data={"title": 'Hi'}, request=request, partial=True)
  if serializer.is_valid():
      data = serializer.save()
      return ResponseMongo(data)        # data == {"title": "Hi", "slug": "hi", "updated": 1716956932}
  ```
  Now the mongo's document with **_id='66557c4188cc1acc1d1e0334'** updated. also '**updated**' field was updated too (because of `auto_now` argument).

  &nbsp;
  **Example 4 (complex nested)**:
  ```python
  from mongoserializer.fields import TimestampField
  from mongoserializer.methods import ResponseMongo, MongoUniqueValidator
  from mongoserializer.serializer import MongoSerializer, MongoListSerializer

  mongo_db = pymongo.MongoClient("mongodb://localhost:27017/")['my_db']


  class CommentListSerializer(MongoListSerializer):  # used in updating of multple comments at same time
      def update(self, _id, serialized):  # _id and serialized are both list

          updates = []
          for comment_id, comment_data in zip(_id, serialized):
              update_set = {f'comments.$.{key}': comment_data[key] for key in comment_data}
              updates.append(pymongo.UpdateOne(
                  {'_id': ObjectId(self.child.father_id), 'comments._id': comment_id},
                  {'$set': update_set}
              ))

          self.child.mongo_collection.bulk_write(updates)
          return serialized


  class CommentSerializer(MongoSerializer):
      
      email = serializers.EmailField(required=False)
      published_date = TimestampField(jalali=True, auto_now_add=True, required=False)
      content = serializers.CharField(validators=[MaxLengthValidator(500)])


  class BlogListMongoSerializer(MongoListSerializer):
      def update(self, _id, validated_data):  # for better performance we used bulk_write to update all instances at once
          
          list_of_serialized = super().update(_id, validated_data)
          updates = []
          for _id, data in zip(_id, list_of_serialized):  # nested fields updated in their own classes
              update_set = {key: value for key, value in data.items()}
              updates.append(pymongo.UpdateOne({'_id': ObjectId(_id)}, {"$set": update_set}))
          self.mongo_collection.bulk_write(updates)
          return list_of_serialized


  class BlogMongoSerializer(MongoSerializer):
      title = serializers.CharField(validators=[MongoUniqueValidator(mongo_db.blog, 'title')], max_length=255)
      slug = serializers.SlugField(required=False)  # Slug generates from title (in to_internal_value)
      published_date = TimestampField(auto_now_add=True, required=False)
      updated = TimestampField(auto_now=True, required=False)
      visible = serializers.BooleanField(default=True)
      author = UserNameSerializer(required=False)
      comments = CommentSerializer(many=True, required=False)  # list auto handles by 'MongoListSerializer'

      class Meta:
          model = mongo_db.file
          list_serializer_class = BlogListMongoSerializer  # handles list for customize purpose

      def to_internal_value(self, data):  # This method fills validated_data directly, after calling is_valid()
          if not data.get('slug') and data.get('title'):
              data['slug'] = slugify(data['title'], allow_unicode=True)
          internal_value = super().to_internal_value(data)

          if self.request:   # if you have pass request kwargs (like BlogMongoSerializer(..., request=reqeust))
              if self.request.user:
                  internal_value['author'] = self.request.user
              else:
                  raise ValidationError({'author': 'Please login to fill blog.author'})
          elif data.get('author'):  # otherwise author's id should provide explicitly in request.data
              internal_value['author'] = get_object_or_404(User, id=data['author'])
          else:
              raise ValidationError({'author': "Please login and pass 'request' parameter or add user's id manually"})
          return internal_value


  item1 = {"title": 'Blog1', 'brief_description': 'about world', 'comments': [{'email': 'a@gmail.com', 'content': 'test1'}, {'email': 'b@gmail.com', 'content': 'test2'}]}
  item2 = {"title": 'Blog2', 'brief_description': 'about galaxy', 'comments': [{'email': 'c@gmail.com', 'content': 'test3'}, {'email': 'd@gmail.com', 'content': 'test4'}]}
  data = [item1, item2]
  serializer = BlogMongoSerializer(data=data, many=True, request=request)
  if serializer.is_valid():
      data = serializer.save()
      return ResponseMongo(data)
  return ResponseMongo(serializer.errors)
  ```

  `data` returned from **.save()** is serialized version of `validated_data` and list (because of many=True):
  ```python
  [OrderedDict([('_id', ObjectId('1234adgt...')), ('title', 'Blog1'), ('slug', 'blog1'), ('published_date', datetime.datetime(2024, 10, 18, 22, 40, 51, 394497)), ('updated', datetime.datetime(2024, 10, 18, 22, 40, 51, 395472)), ('comments', [OrderedDict([('_id', ObjectId('...')), ('email', 'a@gmail.com'), ('published_date', jdatetime.datetime(1403, 7, 27, 22, 40, 51, 399376)), ('content', 'test1')]), OrderedDict([('_id', ObjectId('...')), ('email', 'b@gmail.com'), ('published_date', jdatetime.datetime(1403, 7, 27, 22, 40, 51, 400352)), ('content', 'test2')])]), ('author', <django.contrib.auth.models.AnonymousUser object at 0x0000017A34F64970>)]), OrderedDict([('_id', ObjectId('...')), ('title', 'Blog2'), ('slug', 'blog2'), ('published_date', datetime.datetime(2024, 10, 18, 22, 40, 51, 402305)), ('updated', datetime.datetime(2024, 10, 18, 22, 40, 51, 402305)), ('comments', [OrderedDict([('_id', ObjectId('...')), ('email', 'c@gmail.com'), ('published_date', jdatetime.datetime(1403, 7, 27, 22, 40, 51, 402305)), ('content', 'test3')]), OrderedDict([('_id', ObjectId('...')), ('email', 'd@gmail.com'), ('published_date', jdatetime.datetime(1403, 7, 27, 22, 40, 51, 403281)), ('content', 'test4')])]), ('author', <django.contrib.auth.models.AnonymousUser object at 0x0000017A34F64970>)])]
  ```

  &nbsp;
  **Example 4 (updating)**:
  ```python
  ids = ['671b8ab3437203dcfab4ebda', '671b8ab3437203dcfab4ebdd']
  u_item1 = {"title": 'Blog5', 'comments': [{'_id': '671b8ab3437203dcfab4ebdb', 'email': 'a@gmail.com'}]}
  u_item2 = {"title": 'Blog6', 'comments': [{'_id': '671b8ab3437203dcfab4ebde', 'email': 'cc@gmail.com'}, {'_id': '671b8ab3437203dcfab4ebdf', 'email': 'dd@gmail.com'}]}
  serializer = BlogMongoSerializer(_id=ids, data=[u_item1, u_item2], many=True, partial=True, request=request)
  if serializer.is_valid():
      data = serializer.save()
      return ResponseMongo(data)
  else:
      return ResponseMongo(serializer.errors)
  ```
  Now the mongo's documents with **_id='671b8ab3437203dcfab4ebda'** and **_id='671b8ab3437203dcfab4ebdd'** along all nested fields (like comment's documents which points via _id) updated.

  &nbsp;
  **Example 5 (directly save to mongo)**:
  ```python
  serializer = BlogMongoSerializer(_id="66557c4188cc1acc1d1e0334", data={"author": {'id': 1}}, request=request, partial=True)
  if serializer.is_valid():
      serialized = serializer.serialize_and_filter(serializer.validated_data)
      serialized['author']['user_name'] = serialized['author']['user_name'].replace('1', '_one')  # change 'user1' to 'user_one'
      mongo_db.blog.update_one({'_id': ObjectId("66557c4188cc1acc1d1e0334")}, {"$set": {'author.user_name': serialized['author']['user_name']}})
      return ResponseMongo(serialized)
  ```
  Here we obtained final data ready to save, by `serialize_and_filter()` method. after that, the author's **user_name** is changed to 'user_one' and directly saved it to the document.


  &nbsp;
  <a name="reading-phase"></a>          <!-- required, to work internal links in pypi.org -->

  Now after using `MongoSerializer` for writing blogs in MongoDB, you can show it directly or via serializers.


  ```python
  from bson import ObjectId

  class PostDetail(views.APIView):
      def get(self, request, *args, **kwargs):
          post = blog_col.find_one({"_id": ObjectId(kwargs['_id'])})
          return ResponseMongo(post)
  ```



  For blog list you can create `BlogListSerializer` and for blog detail (page) `BlogDetailSerializer`.

  ```python
  from mongoserializer.serializer import MongoSerializer
  from mongoserializer.fields import TimestampField
  from mongoserializer.methods import ResponseMongo, MongoUniqueValidator

  class BlogListSerializer(MongoSerializer):
      title = serializers.CharField(validators=[MongoUniqueValidator(mongo_db.blog, 'title')], max_length=255)
      slug = serializers.SlugField(required=False)  # Slug generates from title (in to_internal_value)


  class BlogDetailSerializer(MongoSerializer):
      title = serializers.CharField(validators=[MongoUniqueValidator(mongo_db.blog, 'title')], max_length=255)
      slug = serializers.SlugField(required=False)  # Slug generates from title (in to_internal_value)
      published_date = TimestampField(auto_now_add=True, required=False)
      updated = TimestampField(auto_now=True, required=False)
      ...
  ```

  &nbsp;
  <a name="read-write-conflicts-in-a-serializer"></a>  <!-- required, to work internal links in pypi.org -->

  If you use `MongoSerializer` class in read/write operations, as is conventional in DRF, you may face serious conflicts.
  suppose a `UserSerializer`, used to save user model in MongoDB and show it again:

  ![Imgur](https://i.imgur.com/yULeog1.jpg)
  so reading phase needs some data that in writing phase may haven't been provided. specially for complex production
  architectures that may contain several nested serializers in a serializer, this could be an actual problem.


  &nbsp;


  Accept a python `datatime`/`jdatetime` object or timestamp and returns an integer timestamp.

  **arguments**:
  - **jalali**:
    Set this to `True` if you work with 'jalali' datetime. The default is `False`
    Note: timestamp of jalali or gregorian datetimes is same (timestamp is universal), so jalali argument here only uses in validation to returns jdatetime object instead of datetime.

  - **auto_now**:
    Similar to 'auto_now' in django, sets a new timestamp in updating.

  - **auto_now_add**:
    Similar to 'auto_now_add' in django, sets a new timestamp only in creation.



  `DateTimeFieldMongo` is subclass of `DateTimeField` from the Django Rest Framework.
  Accepts a python datatime/jdatetime object and returns a datetime string.

  **arguments**:
  - **jalali**:
    Set this to `True` to return 'jalali' datetime. The default is `False`.

  - **auto_now**:
    Similar to 'auto_now' in django, if `True`, sets a new datetime in updating.

  - **auto_now_add**:
    Similar to 'auto_now_add' in django, if `True`, sets a new datetime only in creation.

  **Example**:
  ```python
  from mongoserializer.fields import TimestampField, DateTimeFieldMongo
  from datetime import datetime

  class MyTime(serializers.Serializer):
      timestamp = TimestampField()
      datetime = DateTimeFieldMongo(jalali=True)

  class TestInstance:
    timestamp = 1719208899
    datetime = datetime.now()  # or jdatetime.now(), doesn't difference
  MyTimes({'timestamp': 1719208899, 'datetime': ''})

  MyTimes(TestInstance).data
  {'timestamp': 1719208899, 'datetime': '1403-04-04T09:34:43.031895'}

  data = {'timestamp': 1719208899, 'datetime': '2024-06-24 09:17:46'}
  serializer = MyTimes(data=data)
  serializer.is_valid()
  serializer.validated_data
  {'timestamp': datetime.datetime(2024, 6, 24, 9, 31, 39), 'datetime': jdatetime.datetime(1403, 4, 4, 9, 17, 46)}
  ```


pkgId: 079753ec4442cd9ebff1175e6e3f8fa36971c0c50483bdd2b269b2140e663659
name: python-mongospecs-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for mongospecs
url: https://github.com/jaykv/mongospecs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mongospecs-0.1.4-1.src.rpm
location_href: Packages/python-mongospecs-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Built on top of the https://github.com/GetmeUK/MongoFrames ODM, with:
  - Pydantic (`BaseModel`), attrs (`@define`), and msgspec (`Struct`) support for defining schema models (specs)
  - Type-hints
  - *Spec adapters*
    - Build a spec out of existing BaseModels, attrs classes, or Structs
  - *Raw BSON encode/decode for specs/mongo documents*

  Choose from one of the following:
  * `pip install mongospecs` for msgspec only
  * `pip install mongospecs[pydantic]` for msgspec and pydantic only
  * `pip install mongospecs[attrs]` for msgspec and attrs only
  * `pip install mongospecs[pydantic,attrs]` for msgspec, pydantic, and attrs


  ```python


  from mongospecs.pydantic import Spec


  from mongospecs.msgspec import Spec


  from mongospecs.attrs import Spec


  class Dragon(Spec):
      _collection = "dragons" # Optional. If not defined, uses the class name by default.

      name: str
      breed: Optional[str] = None


  burt = Dragon(name="Burt", breed="Cold-drake")
  print(burt.name)  # Burt
  print(burt.breed) # Cold-drake


  burt.insert()
  print(burt.id)  # inserted document ObjectId


  doc = Dragon.find_one({"name": "Burt"})  # returns raw mongo document


  burt.delete()
  ```


pkgId: e90275d66d96a026936259248a9a3ddba4faee3379c88b2ae91ba39f58bb5a86
name: python-monisha-help
arch: noarch
version: 0.0.103
epoch: 0
release: 1
summary: Development documents and examples for monisha
url: https://github.com/Monisha-1996
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monisha-0.0.103-1.src.rpm
location_href: Packages/python-monisha-help-0.0.103-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
   📦 <a href="https://pypi.org/project/monisha" style="text-decoration:none;">MONISHA</a>
  </p>


  ```python

  from Monisha import views

  value = views(10000)

  print(value)

  ```


pkgId: d8b50ea9effadf68a50f371569962bf655089c53d3dccf8fe63fd1a969d80637
name: python-monitoring-system-server-report-test-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for monitoring-system-server-report-test
url: https://pypi.org/project/monitoring-system-server-report-test/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monitoring-system-server-report-test-0.1.2-1.src.rpm
location_href: Packages/python-monitoring-system-server-report-test-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A simple monitoring system that collects and visualizes system metrics.


  - Collects metrics (CPU, memory) from agents.
  - Stores data in an SQLite database.
  - Provides a web-based dashboard for visualization.


  1. Install dependencies:
     ```bash
     pip install -r requirements.txt


pkgId: fe1d228494413633829f92bd4ceea2698eef5d0ad2de5a2d7332e70ba52d8766
name: python-monome-diii-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for monome-diii
url: https://github.com/monome/diii
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monome-diii-1.0.0-1.src.rpm
location_href: Packages/python-monome-diii-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A basic REPL for iii devices

  A fork of [druid](https://github.com/monome/druid) (which is for [crow](https://github.com/monome/crow))



  Requirements:
  - Python 3.6+
    - Windows & OS X: https://www.python.org/downloads/
    - Linux: `sudo apt-get install python3 python3-pip` or equivalent
  - `pip` and `setuptools`
  - `pyserial` and `prompt_toolkit`

  Note: you might need to use `python` and `pip` instead of `python3` and `pip3` depending on your platform. If `python3` is not found, check that you have python >= 3.6 with `python --version`.

  Install and run:
  ```bash

  pip3 install monome-diii

  diii
  ```



  Start by running `diii`

  - type q (enter) to quit.
  - type h (enter) for a list of special commands.

  - will reconnect to device after a disconnect / restart
  - scrollable console history

  Example:

  ```
    q to quit. h for help

  > x=6

  > print(x)
  6

  > q
  ```

  Diagnostic logs are written to `diii.log`.



  Sometimes you don't need the repl, but just want to upload/download scripts to/from device. You can do so directly from the command line with the `upload` and `download` commands.



  ```
  diii upload script.lua
  ```

  Uploads the provided lua file `script.lua` to device and stores it in flash to be executed on boot.



  ```
  diii download > feathers.lua
  ```

  Grabs the script currently stored on device, and pastes the result into a new file `feathers.lua`.


pkgId: b78e76b597959267d7a858e607939551819045266e9627ad5adef556fa5c57c6
name: python-monopoly-core-help
arch: noarch
version: 0.13.6
epoch: 0
release: 1
summary: Development documents and examples for monopoly-core
url: https://github.com/benjamin-awd/monopoly
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monopoly-core-0.13.6-1.src.rpm
location_href: Packages/python-monopoly-core-help-0.13.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://monopoly.streamlit.app)
  [![Tests](https://github.com/benjamin-awd/monopoly/actions/workflows/tests.yaml/badge.svg?branch=main&event=push)](https://github.com/benjamin-awd/monopoly/actions/workflows/tests.yaml)
  [![CI](https://github.com/benjamin-awd/monopoly/actions/workflows/ci.yaml/badge.svg?branch=main&event=push)](https://github.com/benjamin-awd/monopoly/actions/workflows/ci.yaml)
  [![License: AGPL 3.0](https://img.shields.io/badge/License-AGPL%203.0-blue)](https://opensource.org/license/agpl-v3)
  Monopoly is a Python library & CLI that converts bank statement PDFs to CSV.
  ![](https://raw.githubusercontent.com/benjamin-awd/monopoly/main/docs/monopoly.gif)
  Supported banks:
  | Bank                 | Credit Statement   | Debit Statement       |
  |----------------------|--------------------|-----------------------|
  | Bank of America      | ✅                 | ❌                   |
  | Chase                | ✅                 | ❌                   |
  | Citibank             | ✅                 | ❌                   |
  | DBS/POSB             | ✅                 | ✅                   |
  | HSBC                 | ✅                 | ❌                   |
  | Maybank              | ✅                 | ✅                   |
  | OCBC                 | ✅                 | ✅                   |
  | Standard Chartered   | ✅                 | ❌                   |
  | UOB                  | ✅                 | ✅                   |
  | Zürcher Kantonalbank | ❌                 | ✅                   |

  Monopoly is a pip-installable Python package on [PyPI](https://pypi.org/project/monopoly-core) under the name `monopoly-core`.
  Since Monopoly uses `pdftotext`, you'll need to install additional dependencies:
  ```sh
  apt-get install build-essential libpoppler-cpp-dev pkg-config ocrmypdf
  ```
  or
  ```sh
  brew install gcc@11 pkg-config poppler ocrmypdf
  ```
  Then install with pipx:
  ```sh
  pipx install monopoly-core
  ```

  Monopoly runs in your terminal, allowing you to extract, transform and write bank statements to a CSV file.
  To list commands and options:
  ```sh
  monopoly --help
  ```
  You can run it on a single statement
  ```sh
  monopoly src/monopoly/examples/example_statement.pdf
  ```
  or multiple statements
  ```sh
  monopoly ./statements
  ```
  If you need to run monopoly on a password protected file, ensure that passwords are set in the .env file:
  ```sh
  cp .env.template .env
  PDF_PASSWORDS=["password1","password2"]
  ```
  Monopoly can also be run as a Python [library](src/monopoly/examples/single_statement.py):
  ```bash
  python3 src/monopoly/examples/single_statement.py
  ```

  - Parses PDFs using predefined configuration classes per bank.
  - Handles locked PDFs with credentials passed via environment variables.
  - Supports adding OCR for image-based bank statements.
  - Provides a generic parser that can be used without any predefined configuration (caveat emptor).
  - Includes a safety check (enabled by default) that validates totals for debit or credit statements.

  Clone the repo
  ```bash
  git clone https://github.com/benjamin-awd/monopoly.git
  ```
  Install dependencies using [Homebrew](https://brew.sh/)
  ```bash
  brew install make
  make setup
  brew bundle
  ```


pkgId: e840219c9f6882f649c0bff9ed354a651f94f50d09ace971fd4e484664eb012a
name: python-montecarlodata-help
arch: noarch
version: 0.110.0
epoch: 0
release: 1
summary: Development documents and examples for montecarlodata
url: https://www.montecarlodata.com/
rpm_license: Apache Software License (Apache 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-montecarlodata-0.110.0-1.src.rpm
location_href: Packages/python-montecarlodata-help-0.110.0-1.noarch.rpm
checksum_type: sha256
description:
  Monte Carlo's Alpha CLI!



  Requires Python 3.8 or greater. Normally you can install and update using `pip`. For instance:

  ```shell
  pip install virtualenv
  virtualenv venv
  . venv/bin/activate

  pip install -U montecarlodata
  ```

  Developers of the CLI can use:

  ```shell
  pip install virtualenv
  make install
  . venv/bin/activate
  pre-commit install
  ```

  Either way confirm the installation by running:

  ```shell
  montecarlo --version
  ```

  If the Python requirement does not work for you please reach out to `support@montecarlodata.com`. Docker is an option.



  First time users can configure the tool by following the onscreen prompts:

  ```shell
  montecarlo configure
  ```

  MCD tokens can be generated from the [dashboard](https://getmontecarlo.com/get-token).

  Use the `--help` flag for details on any advanced options (e.g. creating multiple montecarlo profiles) or
  see docs [here][cli-docs].

  That's it! You can always validate your connection with:

  ```shell
  montecarlo validate
  ```



  Any configuration set by `montecarlo configure` can be found in `~/.mcd/` by default.

  The MCD ID and Token can be overwritten, or even set, by the environment:

  - `MCD_DEFAULT_API_ID`
  - `MCD_DEFAULT_API_TOKEN`

  These two are required either as part of `configure` or as environment variables.

  The following values can also be set by the environment:

  - `MCD_API_ENDPOINT` - Overwrite the default API endpoint
  - `MCD_VERBOSE_ERRORS` - Enable verbose logging on errors (default=false)



  Documentation for commands, options, and arguments can be found [here][cli-docs].

  You can also use `montecarlo help` to echo all help text or use the `--help` flag on any command.





  ```shell
  docker build -t montecarlo .
  docker run -e MCD_DEFAULT_API_ID='<ID>' -e MCD_DEFAULT_API_TOKEN='<TOKEN>' montecarlo --version
  ```

  Replace `--version` with any sub-commands or options. If interacting with files those directories will probably need to be mounted too.



  ```shell
  $ montecarlo configure --profile-name zeus --config-path .
  Key ID: 1234
  Secret:

  $ cat ./profiles.ini
  [zeus]
  mcd_id = 1234
  mcd_token = 5678
  ```



  ```shell
  $ montecarlo integrations list
  ╒══════════════════╤══════════════════════════════════════╤══════════════════════════════════╕
  │ Integration      │ ID                                   │ Created on (UTC)                 │
  ╞══════════════════╪══════════════════════════════════════╪══════════════════════════════════╡
  │ Odin             │ 58005657-2914-4701-9a11-260ac425b14e │ 2021-01-02T01:30:52.806602+00:00 │
  ├──────────────────┼──────────────────────────────────────┼──────────────────────────────────┤
  │ Thor             │ 926816bd-ab17-4f95-a953-fa14482c59de │ 2021-01-02T01:31:19.892205+00:00 │
  ├──────────────────┼──────────────────────────────────────┼──────────────────────────────────┤
  │ Loki             │ 1cf1dc0d-d8ec-4c85-8e64-57ab2ad8e023 │ 2021-01-02T01:32:37.709747+00:00 │
  ╘══════════════════╧══════════════════════════════════════╧══════════════════════════════════╛
  ```



  ```shell
  $ montecarlo monitors apply --namespace my-monitors

  Gathering monitor configuration files.
  - models/customer_success/schema.yml - Embedded monitor configuration found.
  - models/customer_success/schema.yml - Monitor configuration found.
  - models/lineage/schema.yml - Embedded monitor configuration found.

  Modifications:
  - ResourceModificationType.UPDATE - Monitor: type=stats, table=analytics:prod.customer_360
  - ResourceModificationType.UPDATE - Monitor: type=categories, table=analytics:prod.customer_360
  - ResourceModificationType.UPDATE - Monitor: type=stats, table=analytics:prod_lineage.lineage_nodes
  - ResourceModificationType.UPDATE - Freshness SLI: table=analytics:prod.customer_360, freshness_threshold=30
  ```



  ```shell
  $ montecarlo import dbt-manifest --dbt-manifest-file target/manifest.json

  Importing DBT objects into Monte Carlo catalog. please wait...

  Imported a total of 51 DBT objects into Monte Carlo catalog.
  ```



  Locally `make test` will run all tests. CircleCI manages all testing for deployment.

  To publish a new release, navigate to [Releases](https://github.com/monte-carlo-data/cli/releases) in the GitHub repo and then:
  - Click "Draft a new release"
  - In the "Choose a tag" dropdown, type the new version number, for example `v1.2.3` and click "Create a new tag"
  - Follow the format from previous releases for the description
  - Leave "Set as the latest release" checked
  - Click "Publish release"
  - CircleCI will take care of publishing a new package to [PyPI](https://pypi.org/project/montecarlodata/) and generating documentation.



  Apache 2.0 - See the [LICENSE](http://www.apache.org/licenses/LICENSE-2.0) for more information.

  [cli-docs]: https://clidocs.getmontecarlo.com/


pkgId: 73316b1e5608a5cc467ad2942cd558d3dd27b6a812e97d6537a187f42ef74558
name: python-montty-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for montty
url: https://github.com/GwynDavies/montty
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-montty-1.0.3-1.src.rpm
location_href: Packages/python-montty-help-1.0.3-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024-2025 Gwyn Davies  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: da7bcdec9b95c1866fb1896cc85eaf138997f26f2c841404a9886f91182fcd3f
name: python-monumenten-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for monumenten
url: https://github.com/woonstadrotterdam/monumenten
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monumenten-0.2.0-1.src.rpm
location_href: Packages/python-monumenten-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Een Python package voor het ophalen van monumentgegevens van Nederlandse overheids-API's. Momenteel is het mogelijk om de status van rijksmonumenten, gemeentelijke monumenten en beschermde gezichten op te halen. Eventueel in VERA-referentiedataformaat.

  Door middel van de package is het mogelijk om, indienst gewenst, voor tienduizenden verblijfsobjecten per seconde monumentgegevens op te halen. Er zijn geen API-keys nodig.

  > In VERA-referentiedataformaat wordt geen onderscheid gemaakt tussen beschermde stads- en dorpsgezichten. Alle beschermde gezichten worden teruggegeven als beschermd stadsgezicht.



  `pip install monumenten`





  ```python
  import asyncio
  import json

  from monumenten import MonumentenClient

  async def main():
      bag_verblijfsobject_ids = [
          "0599010000360091",
          "0599010000486642",
          "0599010000281115",
          "0599010000146141",
      ]

      async with MonumentenClient() as client:
          result = await client.process_from_list(bag_verblijfsobject_ids)
          print(json.dumps(result, indent=2))


  if __name__ == "__main__":
      asyncio.run(main())


  await main()
  ```

  ```python

  {
    "0599010000360091": {
      "is_rijksmonument": true,
      "rijksmonument_nummer": "524327",
      "rijksmonument_url": "https://monumentenregister.cultureelerfgoed.nl/monumenten/524327",
      "is_beschermd_gezicht": false,
      "beschermd_gezicht_naam": null,
      "is_gemeentelijk_monument": false,
      "grondslag_gemeentelijk_monument": null
    },
    "0599010000486642": {
      "is_rijksmonument": false,
      "rijksmonument_nummer": null,
      "rijksmonument_url": null,
      "is_beschermd_gezicht": false,
      "beschermd_gezicht_naam": null,
      "is_gemeentelijk_monument": false,
      "grondslag_gemeentelijk_monument": null
    },
    "0599010000281115": {
      "is_rijksmonument": false,
      "rijksmonument_nummer": null,
      "rijksmonument_url": null,
      "is_beschermd_gezicht": true,
      "beschermd_gezicht_naam": "Kralingen - Midden",
      "is_gemeentelijk_monument": false,
      "grondslag_gemeentelijk_monument": null
    },
    "0599010000146141": {
      "is_rijksmonument": false,
      "rijksmonument_nummer": null,
      "rijksmonument_url": null,
      "is_beschermd_gezicht": true,
      "beschermd_gezicht_naam": "Rotterdam - Waterproject",
      "is_gemeentelijk_monument": true,
      "grondslag_gemeentelijk_monument": "Gemeentewet: Aanwijzing gemeentelijk monument (voorbescherming, aanwijzing, afschrift)"
    }
  }
  ```



  ```python

  import asyncio

  from monumenten import MonumentenClient

  async def main():
      bag_verblijfsobject_ids = [
          "0599010000360091",
          "0599010000486642",
          "0599010000281115",
          "0599010000146141",
      ]

      async with MonumentenClient() as client:
          result = await client.process_from_list(
              bag_verblijfsobject_ids,
              to_vera=True # zet to_vera=True
          )
          print(result)


  if __name__ == "__main__":
      asyncio.run(main())


  await main()
  ```

  ```python

  {
      '0599010000360091': [{'code': 'RIJ', 'naam': 'Rijksmonument'}],
      '0599010000486642': [],
      '0599010000281115': [{'code': 'STA', 'naam': 'Beschermd stadsgezicht'}],
      '0599010000146141': [
          {'code': 'STA', 'naam': 'Beschermd stadsgezicht'},
          {'code': 'GEM', 'naam': 'Gemeentelijk monument'}
      ]
  }
  ```



  ```python
  import asyncio

  import pandas as pd
  from monumenten import MonumentenClient


  async def main():

      input_df = pd.DataFrame(
          {
              "bag_verblijfsobject_id": [
                  "0599010000360091",
                  "0599010000486642",
                  "0599010000360022",
                  "0599010000360096",
                  "0599010000183527",
                  "0599010400025880",
                  "0599010000281115",
                  "0599010000146141",
              ]
          }
      ) # of lees van een csv of een ander bestand in

      async with MonumentenClient() as client:
          result = await client.process_from_df(
              df=input_df, verblijfsobject_id_col="bag_verblijfsobject_id"
          )
          result.to_csv("monumenten.csv", index=False)


  if __name__ == "__main__":
      asyncio.run(main())


  await main()
  ```

  | bag_verblijfsobject_id | is_rijksmonument | rijksmonument_nummer | rijksmonument_url                                                | is_beschermd_gezicht | beschermd_gezicht_naam          | is_gemeentelijk_monument | grondslag                                                                              |
  | ---------------------- | ---------------- | -------------------- | ---------------------------------------------------------------- | -------------------- | ------------------------------- | ------------------------ | -------------------------------------------------------------------------------------- |
  | 0599010000360091       | True             | 524327               | https://monumentenregister.cultureelerfgoed.nl/monumenten/524327 | False                |                                 | False                    |                                                                                        |
  | 0599010000486642       | False            |                      |                                                                  | False                |                                 | False                    |                                                                                        |
  | 0599010000360022       | True             | 524327               | https://monumentenregister.cultureelerfgoed.nl/monumenten/524327 | False                |                                 | False                    |                                                                                        |
  | 0599010000360096       | True             | 524327               | https://monumentenregister.cultureelerfgoed.nl/monumenten/524327 | False                |                                 | False                    |                                                                                        |
  | 0599010000183527       | True             | 32807                | https://monumentenregister.cultureelerfgoed.nl/monumenten/32807  | True                 | Rotterdam - Scheepvaartkwartier | False                    |                                                                                        |
  | 0599010400025880       | False            |                      |                                                                  | False                |                                 | False                    |                                                                                        |
  | 0599010000281115       | False            |                      |                                                                  | True                 | Kralingen - Midden              | False                    |                                                                                        |
  | 0599010000146141       | False            |                      |                                                                  | True                 | Rotterdam - Waterproject        | True                     | Gemeentewet: Aanwijzing gemeentelijk monument (voorbescherming, aanwijzing, afschrift) |

rpm_license:
  MIT License  Copyright (c) 2024 Woonstad Rotterdam  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: 2e7871aaa4b48733614424e50d27455cf98e2e9c27b6bc0ede3ad7606475abae
name: python-monze-help
arch: noarch
version: 0.1.910
epoch: 0
release: 1
summary: Development documents and examples for monze
url: https://github.com/jeex/monze
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-monze-0.1.910-1.src.rpm
location_href: Packages/python-monze-help-0.1.910-1.noarch.rpm
checksum_type: sha256
description:
  <!-- [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/) -->
  <!-- python3 -m pip install --upgrade build for building the thing -->
  <!-- python3 -m build -->
  <!-- twine upload dist/* for uploading to pypi -->


pkgId: 82cda6507d2ed8be3b9ab41daaa493f899741a58f74772e282c17ffba9afa1ab
name: python-moped-help
arch: noarch
version: 1.13.92
epoch: 0
release: 1
summary: Development documents and examples for moped
url: https://gitlab.com/marvin.vanaalst/moped
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moped-1.13.92-1.src.rpm
location_href: Packages/python-moped-help-1.13.92-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://img.shields.io/badge/DOI-10.3390%2Fmetabo12040275-blue)](https://doi.org/10.3390/metabo12040275)
  [![pipeline status](https://gitlab.com/qtb-hhu/moped/badges/main/pipeline.svg)](https://gitlab.com/qtb-hhu/moped/-/commits/main)
  [![coverage report](https://gitlab.com/qtb-hhu/moped/badges/main/coverage.svg)](https://gitlab.com/qtb-hhu/moped/-/commits/main)
  [![Documentation Status](https://readthedocs.org/projects/moped/badge/?version=latest)](https://moped.readthedocs.io/en/latest/?badge=latest)
  [![PyPi](https://img.shields.io/pypi/v/moped)](https://pypi.org/project/moped/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
  [![Downloads](https://pepy.tech/badge/moped)](https://pepy.tech/project/moped)




  You can install moped using pip

  `pip install moped`

  However, you will still need to install NCBI Blast if you want to use the genome / proteome reconstruction methods

  If you are using conda or mamba, you can install blast from bioconda:

  `conda install -c bioconda blast==2.12.0`
  `mamba install -c bioconda blast==2.12.0`

  If you want to install BLAST yourself:
  - download the latest blast version from [NCBI](ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/)
  - Extract the downloaded folder to a path of your liking
  - Add blast to your path e.g. by adding the following line to your .bashrc
    - `export PATH="your_blast_directory/bin:$PATH"`




  Check out our tutorial on [readthedocs](https://moped.readthedocs.io/en/latest/)




  All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome.
  If you want to contribute code to the project, please consider our [contribution guide](https://gitlab.com/qtb-hhu/moped/-/blob/main/CONTRIBUTING.md)



  moped is licensed under [GPL 3](https://gitlab.com/qtb-hhu/moped/-/blob/main/LICENSE)



  If you experience issues using the software please contact us through our [issues](https://gitlab.com/qtb-hhu/moped/issues) page.


pkgId: 0dc4835afdce7d8691ce7891f021b2d65673a358af49ae1f9eb398f278032e2a
name: python-mopsy-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for mopsy
url: https://github.com/jkanche/mopsy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mopsy-0.3.0-1.src.rpm
location_href: Packages/python-mopsy-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)
  [![PyPI-Server](https://img.shields.io/pypi/v/mopsy.svg)](https://pypi.org/project/mopsy/)
  ![Unit tests](https://github.com/BiocPy/mopsy/actions/workflows/pypi-test.yml/badge.svg)



  Convenience library to perform row/column operations over numpy and scipy matrices. Provides an interface similar to base R matrix methods/MatrixStats methods in python.



  Install from [pypi](https://pypi.org/project/mopsy/)

  ```shell
  pip install mopsy
  ```



  ```python
  from mopsy import colsum
  import random from rd

  from scipy.sparse import random
  mat = random(10, 150, 0.25)


  ngrps = 15
  gsets = [x for x in range(15)]
  groups = [rd.choice(gsets) for x in range(mat.shape[axis])]

  colsum(mat, groups)
  ```

  Methods are available to perform `sum`, `median`, `mean` along any axis. a generic `apply` method is also available for perform row-wise or column-wise operations.

  <!-- pyscaffold-notes -->



  This project has been set up using PyScaffold 4.1.1. For details and usage
  information on PyScaffold see https://pyscaffold.org/.


pkgId: a0aeed32b28524580a62f0ddc4ece20439f494584a8874c60e4738456a57657e
name: python-morningstar-data-help
arch: noarch
version: 1.10.3
epoch: 0
release: 1
summary: Development documents and examples for morningstar-data
url: https://www.morningstar.com/products/md-python-package
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-morningstar-data-1.10.3-1.src.rpm
location_href: Packages/python-morningstar-data-help-1.10.3-1.noarch.rpm
checksum_type: sha256
description:
  The morningstar_data Python package provides users quick programmatic access to Morningstar data. It is a building block for doing practical investment data analysis in Python.






  ```
  pip install morningstar-data
  ```


  ```
  conda install -c conda-forge morningstar-data
  ```

  **Warning**: Importing the package before authenticating will produce an error. See below for authentication steps.



  1. Open [Analytics Lab](https://analyticslab.morningstar.com/) in your browser
  2. Login with your Morningstar Direct credentials
  3. On the top ribbon in the "Analytics Lab" dropdown menu select "Copy Authentication Token". This will copy your token to the clipboard.

  ![copy auth token](https://al-morningstar-readme-images-temp.s3.amazonaws.com/copy_auth_token.png)


  Set the environment variable `MD_AUTH_TOKEN` using the token you retrieved previously


  `export MD_AUTH_TOKEN="paste copied token here"`



  ```

  import os
  import morningstar_data as md

  os.environ['MD_AUTH_TOKEN']="paste copied token here"

  md.direct.get_morningstar_data_sets()
  ```



  The morningstar_data package is tested with

  |             | Main version (latest)
  |-------------|------------------------------|
  | Python      | 3.8, 3.9, 3.10, 3.11         |
  | Pandas      | 1.5                          |




  This is an example of retrieving data for a saved investment list and data set from Morningstar Direct. See more usage examples in the Python package [documentation](https://docs-analyticslab.morningstar.com/latest/index.html) and tutorial notebooks in [Analytics Lab](https://analyticslab.morningstar.com/).

  ```

  lists = md.direct.user_items.get_investment_lists()

  | id                                   | name                                       |
  |--------------------------------------|--------------------------------------------|
  | 8CA07FB7-DFFE-4440-9ED7-6498CC074F11 | Morningstar Prospects                      |
  | AE322592-5A3E-4B31-B889-16D8E76F48D3 | Sustainable Landscape U.S. Funds Q4 2021   |
  | 83D337A2-1CF2-4E66-A94D-2B8EE554AC23 | Sustainable Landscape Global Funds Q4 2021 |
  | ...                                  | ...                                        |


  morningstar_data_sets = md.direct.lookup.get_morningstar_data_sets()

  | datasetId | name                                          |
  |-----------|-----------------------------------------------|
  | 0218-0020 | Snapshot                                      |
  | 0218-0446 | Sustainability: ESG Risk (Company)            |
  | 0218-0481 | Sustainability: Portfolio Sustainability Risk |
  | ...       | ...                                           |



  data = md.direct.get_investment_data(investments=lists["id"][0], data_points=morningstar_data_sets["datasetId"][0])

  | Id            | Name                                    | Base Currency | ... |
  |---------------|-----------------------------------------|---------------|-----|
  | F00001AHPT;FO | Hartford Schroders Sustainable Cr Bd I  | US Dollar     | ... |
  | F000014ZNT;FE | iShares ESG Aware Aggressive Allc ETF   | US Dollar     | ... |
  | F00000WUF1;FE | iShares MSCI Global Sust Dev Goals ETF  | US Dollar     | ... |
  | ...           | ...                                     | ...           | ... |

  ```



  Documentation is hosted at https://docs-analyticslab.morningstar.com/latest/index.html

  Find the version you are using with `md.__version__`



  The Morningstar Data Extension in [Analytics Lab](https://analyticslab.morningstar.com/) is the most convenient tool for locating data points and various saved objects to be used in morningstar_data function calls. You can browse data points, saved investment lists, search criteria, performance reports and more. Drag and drop the object you are interested in into a notebook and the corresponding Python code will be generated for you.

  ![direct extension](https://al-morningstar-readme-images-temp.s3.amazonaws.com/morningstar_direct_extension.png)







  |Type of Limit| Restriction  |
  |-------------|--------------|
  |Limits | Morningstar Direct is exclusively licensed for individual usage. Users of Morningstar Direct are strictly prohibited from disclosing their login credentials, deploying instances of Morningstar Direct on a server, or utilizing, distributing, or redistributing data in a manner contradictory to their organization's agreement with Morningstar. Moreover, Morningstar Direct users are prohibited from employing information in any manner that would contravene the regulations and policies established by third-party providers.|
  |Call Limits | When utilizing the morningstar_data Python package for data extraction, it's important to be aware of the limitations imposed on the number of requests you can make or the amount of data you can receive. These limitations are in place to ensure efficient usage of the resources and maintain the overall performance of the system.|
  |Daily Limits | Limits are in place and can be reached when making requests or receiving data within a single day. These limits are determined either by the number of requests made or the quantity of data received. It is important to keep these limitations in mind while working with the data to ensure compliance and avoid any interruptions in your data processing tasks.|
  |Content Limits |Content limits are governed by entitlements, which are determined by the specific product variant and add-ons purchased. These limits are put in place to regulate the amount of content accessible within the platform. It is important to be aware of these entitlements and ensure they align with your requirements and data processing tasks.|



  |Type of Limit| For this Item | Has this limitation|
  |-------------|---------------|--------------------|
  |Daily Limits | Number of Cells per Day | The count of data retrieved from the morningstar_data Python package per day cannot exceed 500,000 cells per day. This count of data is summed across all client applications connected to the same Morningstar Direct instance. In the event you reach your limit, please contact your Sales Representative or Customer Success Manager at Morningstar.|
  |Daily Limits | Number Of investments in an Investment List | The size of an investment list in Morningstar Direct cannot exceed 30,000 investments in a single query.|
  |Daily Limits | Number of data points returned per request |Data point limits are uniform across the type of data being retrieved. That is, the limits apply to time series data, static data, and so on, but are not aggregated across all applications. A custom data set in Morningstar Direct is limited to 1,000 data points.|
  |Content/Entitlement Limits | Third-pary data usage|Additional morningstar_data Python package limitations may be imposed by the providers of the underlying data content. Consult with your Customer Success Manager or Sales Representative to know what third-party provider terms may apply to your use of this data.|



  As you refer to the morningstar_data Python package documentation, you may find some utility functions and additional data query functions that are not yet available for use. Such functions are in testing by internal teams at Morningstar, and they will be available to Morningstar Direct clients in the future.




  A Python package refers to a specialized computer program that can be imported into a development environment to facilitate easier access to specific Morningstar data and the execution of pre-built functions. It consists of a toolkit comprising a predefined collection of functions that assist users in constructing something with ease and efficiency. The utilization of the morningstar_data Python package is subject to the governance of the Apache 2.0 license. An Authorized User is explicitly prohibited from engaging in activities such as translating, disassembling, or separating components of the Python package (e.g., accessing or acquiring Product code in any manner). The sole means of granting Authorized Users permission to employ and manipulate the Python package is by referencing or providing a separate entitlement to do so. However, this permission must not override any other limitations outlined in the Click License about the utilization or distribution of the Product.



  Since the functions (i.e., tools) within the morningstar_data package enable users to extract Morningstar data in various ways, it is imperative to ensure that users extract the data within the constraints specified for them and by the distribution licenses held by Morningstar with their respective firms.



  We authenticate a user's access to the morningstar_data package using an authentication token, which remains valid for 24 hours and can solely be obtained from Analytics Lab. Access to Analytics Lab requires possession of a Direct License. Users are strictly prohibited from sharing their authentication tokens with other individuals, as the usage of the product is tethered to the terms and agreements associated with license of Morningstar Direct.


  The utilization of the morningstar_data Python package entails accessing certain data from Morningstar Direct. Your access and utilization of Morningstar Direct, including its morningstar_data Python package and associated data, are governed by the terms and conditions set forth in your organization’s agreement with Morningstar. Morningstar Direct is an Asset and Wealth management platform that is lawfully licensed for individual use, subject to a login session requirement. A login session is designed to control entitlements and regulate reasonable use for a singular user. To align with the workflow demands of a single user, the morningstar_data Python package imposes restrictions to safeguard the overall platform’s capacity to support the usage levels of all individual Morningstar Direct users accessing data via APIs. The document attached below provides a succinct overview of these various restrictions and elucidates the user experience when encountering them. The specific numerical values for each restriction described herein are not binding and do not create any legal obligations on the part of Morningstar. These restrictions are subject to modification at our sole discretion, without prior notice. It is your sole responsibility to furnish all necessary support pertaining to any applications developed utilizing the morningstar_data Python package. Kindly take note that if you have intentions to resell or distribute any applications or data developed using the morningstar_data Python package to third parties, it is imperative to engage in a distribution license agreement with us. Please contact your Customer Success Manager or Sales Representative at Morningstar for further information.


pkgId: 0d970b6abfbad8694650a104a7a63d26346c37761dfcd3a4f8faffeebc92dd0b
name: python-morph-data-help
arch: noarch
version: 0.0.1rc1
epoch: 0
release: 1
summary: Development documents and examples for morph-data
url: https://pypi.org/project/morph-data/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-morph-data-0.0.1rc1-1.src.rpm
location_href: Packages/python-morph-data-help-0.0.1rc1-1.noarch.rpm
checksum_type: sha256
description:
  ![Header](./assets/header.jpg)



  **Morph** is a python-centric full-stack framework for building and deploying data apps.

  - **Fast to start** 🚀 - Allows you to get up and running with just three commands.
  - **Deploy and operate 🌐** - Easily deploy your data apps and manage them in production. Managed cloud is available for user authentication and secure data connection.
  - **No HTML/CSS knowledge required🔰** - With **Markdown-based syntax** and **pre-made components**, you can create flexible, visually appealing designs without writing a single line of HTML or CSS.
  - **Customizable 🛠️** - **Chain Python and SQL** for advanced data workflows. Custom CSS and custom React components are available for building tailored UI.



  1. Install morph

  ```bash
  pip install morph-data
  ```

  1. Create a new project

  ```bash
  morph new
  ```

  3. Start dev server

  ```bash
  morph serve
  ```

  4. Visit `http://localhsot:9002` on browser.



  Understanding the concept of developing a data app in Morph will let you do a flying start.

  1. Develop the data processing in Python and give it an alias.
  2. Create an .mdx file. Each .mdx file becomes a page of your app.
  3. Place the component in the MDX file and specify the alias to connect to.

  ```
  .
  ├─ pages
  │  └─ index.mdx
  ├─ python
  │  └─ closing_deals_vis.py
  └─ sql
     └─ closing_deals.sql
  ```





  1. Create each files in `sql`, `python` and `pages` directories.


  SQL: Using DuckDB to read CSV file.

  ```sql
  {{
      config(
          name = "example_data",
          connection = "DUCKDB"
      )
  }}

  select
      *
  from
      read_csv("example.csv")
  ```


  Python: Using Plotly to create a chart.

  ```python
  import plotly.express as px
  import morph
  from morph import MorphGlobalContext
  @morph.func
  @morph.load_data("example_data")
  def example_chart(context: MorphGlobalContext):
      df = context.data["example_data"].groupby("state").sum(["population"]).reset_index()
      fig = px.bar(df, x="state", y="population")
      return fig
  ```

  MDX: Define the page and connect the data.

  ```typescript
  export const title = "Starter App"



  Morph is a full-stack framework for building data apps using Python, SQL and MDX.



  <Grid cols="2">
    <div>
      <DataTable loadData="example_data" height={300} />
    </div>
    <div>
      <Embed loadData="example_chart" height={300} />
    </div>
  </Grid>
  ```

  2. Run `morph serve` to open the app!

  ![Data App](./assets/sample-data-app.png)



  Visit https://docs.morph-data.io for more documentation.



  Morph is [Apache 2.0](./License.md) licensed.


pkgId: b6fc67da94c3ae5120a78e9a48fb7652836a34de26ddeb93cd1b0ee651163de5
name: python-morphcloud-help
arch: noarch
version: 0.1.14
epoch: 0
release: 1
summary: Development documents and examples for morphcloud
url: https://pypi.org/project/morphcloud/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-morphcloud-0.1.14-1.src.rpm
location_href: Packages/python-morphcloud-help-0.1.14-1.noarch.rpm
checksum_type: sha256
description:
  MorphCloud is a platform designed to spin up remote AI devboxes we call runtimes.
  It provides a suite of code intelligence tools and a Python SDK to manage, create, delete, and interact with runtime instances.





  Python 3.11 or higher

  Go to [https://cloud.morph.so](https://cloud.morph.so/web/api-keys), log in with the provided credentials and create an API key.

  Set the API key as an environment variable  `MORPH_API_KEY`.



  ```
  pip install morphcloud
  ```

  Export the API key:

  ```
  export MORPH_API_KEY="your-api-key"
  ```



  The SDK provides a Python API to interact with the MorphCloud API.

  The following example creates a minimal vm snapshot, starts and instance then sets up a simple HTTP server and makes an HTTP request to it.

  ```py
  import time
  import requests
  import tempfile
  from morphcloud.api import MorphCloudClient



  client = MorphCloudClient()


  snapshot = client.snapshots.create(vcpus=1, memory=128, disk_size=700, image_id="morphvm-minimal")


  with client.instances.start(snapshot_id=snapshot.id) as instance, instance.ssh() as ssh:
      
      ssh.run(["curl -LsSf https://astral.sh/uv/install.sh | sh"]).raise_on_error()
      ssh.run(["echo 'source $HOME/.local/bin/env' >> $HOME/.bashrc"]).raise_on_error()
      ssh.run(["uv", "python", "install"]).raise_on_error()

      
      with tempfile.NamedTemporaryFile(mode="w") as f:
          f.writelines("<h1>Hello, World!</h1>")
          f.flush()
          ssh.copy_to(f.name, "index.html")

      
      with ssh.run(["uv", "run", "python3", "-m", "http.server", "8080", "--bind", "127.0.0.1"], background=True) as http_server, \
           ssh.tunnel(local_port=8888, remote_port=8080) as tunnel:

          
          time.sleep(1)

          print("HTTP Server:", http_server.stdout)

          print("Making HTTP request")
          response = requests.get("http://127.0.0.1:8888", timeout=10)
          print("HTTP Response:", response.status_code)
          print(response.text)
  ```



  The SDK also provides a command line interface to interact with the MorphCloud API.
  You can use the CLI to create, delete, and manage runtime instances.



  List available images:
  ```bash
  morph image list [--json]
  ```



  ```bash

  morph snapshot list [--json]


  morph snapshot create --image-id <id> --vcpus <n> --memory <mb> --disk-size <mb> [--digest <hash>]


  morph snapshot delete <snapshot-id>
  ```



  ```bash

  morph instance list [--json]


  morph instance start <snapshot-id> [--json]


  morph instance stop <instance-id>


  morph instance get <instance-id>


  morph instance snapshot <instance-id> [--json]


  morph instance branch <instance-id> [--count <n>]
  ```



  ```bash

  morph instance exec <instance-id> <command>


  morph instance ssh <instance-id> [command]


  morph instance port-forward <instance-id> <remote-port> [local-port]


  morph instance expose-http <instance-id> <name> <port>


  morph instance hide-http <instance-id> <name>
  ```



  Deploy and run OCI containers:

  ```bash
  morph instance crun [options] [command]

  Options:
    --image TEXT          Container image (default: python:3.11-slim)
    --expose-http TEXT    HTTP service to expose (format: name:port)
    --vcpus INTEGER      Number of VCPUs (default: 1)
    --memory INTEGER     Memory in MB (default: 128)
    --disk-size INTEGER  Disk size in MB (default: 700)
    --force-rebuild      Force rebuild the container
    --instance-id TEXT   Use existing instance instead of creating new
    --verbose           Enable verbose logging (default: True)
    --json              Output in JSON format
  ```



  Start an interactive chat session with an instance:

  **Note:** You'll need to set `ANTHROPIC_API_KEY` environment variable to use this command.

  ```bash
  morph instance chat <instance-id> [instructions]
  ```


pkgId: 46f0d55bae25603f0778c0c06ef913f6b7fcca70adc38a4d75944eb456609e3a
name: python-morphi-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for morphi
url: https://github.com/level12/morphi
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-morphi-0.3.0-1.src.rpm
location_href: Packages/python-morphi-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  ``morphi`` was born out of the need to create a distributable library with internally-localized
  text. Although there are several existing packages which deal with translatable text, they all
  seem to focus on standalone applications; there seems to be very little available for working
  with messages that are distributed along with a packaged library.


pkgId: b91981851b65be584ad325d7a176e0a8892f78cbcf9a6b62ddb3013d22286555
name: python-mosek-license-server-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for mosek-license-server
url: https://pypi.org/project/mosek-license-server/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mosek-license-server-1.2.1-1.src.rpm
location_href: Packages/python-mosek-license-server-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/mosek-license-server.svg)](https://badge.fury.io/py/mosek-license-server)
  [![Apache 2.0 License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)](https://github.com/tschm/mosek-license-server/blob/main/LICENSE)
  [![Downloads](https://static.pepy.tech/badge/mosek-license-server/month)](https://pepy.tech/project/mosek-license-server)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/tschm/mosek-license-server/main.svg)](https://results.pre-commit.ci/latest/github/tschm/mosek-license-server/main)
  [![Coverage Status](https://coveralls.io/repos/github/tschm/mosek-license-server/badge.svg?branch=main)](https://coveralls.io/github/tschm/mosek-license-server?branch=main)

  Using a [nginx image](https://hub.docker.com/_/nginx/) we expose a Mosek license
  on a server to be accessible from various research machines without sharing the actual
  license file in the underlying repositories.

  This repository serves two purposes. It exposes the server but it is also the home
  for a little Python package to inject the license into your programs.

  We solve a common problem here. Assume $20$ researchers work on $50$ different strategies.
  Using local copies of the same license file is a tedious exercise as
  the file needs to get updated once a year.
  Rather, each strategy would connect to the server to fetch a license using the mosek_license
  Python package. Once the strategy expires we only need to update the server.
  No change for the strategies is required.





  Copy the license file you have received (from Mosek) into the `web` folder.
  Name it `mosek`.

  The file should look like

  ```bash
  START_LICENSE
  VENDOR MOSEKLM

  FEATURE PTS MOSEKLM 10 31-jan-2024 uncounted ...

  FEATURE PTON MOSEKLM 10 31-jan-2024 uncounted ...
  END_LICENSE
  ```



  Share the web folder (after you have copied your personal Mosek license into)
  via

  ```bash
  docker run --name mosek -v $PWD/web:/usr/share/nginx/html:ro -p 8080:80 -d nginx
  ```

  The license will now be exposed via `http://localhost:8080/mosek`

  As an alternative you can run the script

  ```bash
  ./start_server.sh
  ```



  Install via

  ```bash
  pip install mosek-license-server
  ```

  and then

  ```python
  import mosek

  from mosek_license import license

  license.upsert(server="http://localhost:8080/mosek")
  ```



  In case you experience problems please check:

  - the license file is named `mosek`
  - the license file starts with `START_LICENSE`
  - the license file ends with `END_LICENSE`
  - the dates in the license file are still in the future
  - the server is running, e.g. docker ps -all (and check for mosek)
  - you can download a license file from the server, e.g.

  ```bash
  curl <http://localhost:8080/mosek>
  ```

  works.

  - you can run the demo in the demo folder

  Still lost? Please open an issue.



  You need to install [task](https://taskfile.dev).
  Starting with

  ```bash
  task simulator:install
  ```

  will install [uv](https://github.com/astral-sh/uv) and create
  the virtual environment defined in
  pyproject.toml and locked in uv.lock.


pkgId: d98a7d542462b9fcebe651b6a6b30b71e668b10de1e26407e359c523a4d7d181
name: python-mosheh-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for mosheh
url: https://pypi.org/project/mosheh/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mosheh-1.3.1-1.src.rpm
location_href: Packages/python-mosheh-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <img src="https://raw.githubusercontent.com/lucasGoncSilva/mosheh/refs/heads/main/.github/logo.svg" height="300" width="300" alt="Logo Mosheh" />
    <br>
    Mosheh
  </h1>

  ![PyPI - Version](https://img.shields.io/pypi/v/mosheh?labelColor=101010)
  ![GitHub License](https://img.shields.io/github/license/LucasGoncSilva/mosheh?labelColor=101010)
  ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/LucasGoncSilva/mosheh/unittest.yml?labelColor=101010)

  [![Changelog](https://img.shields.io/badge/here-here?style=for-the-badge&label=changelog&labelColor=101010&color=fff)](https://github.com/LucasGoncSilva/mosheh/blob/main/.github/CHANGELOG.md)

  [![PyPI](https://img.shields.io/badge/here-here?style=for-the-badge&label=PyPI&labelColor=3e6ea8&color=f3e136)](https://pypi.org/project/mosheh/)

  Mosheh, a tool for creating docs for projects, from Python to Python.

  Basically, Mosheh lists all files you points to, saves every single notorious statement of definition on each file iterated, all using Python `ast` native module for handling the AST and then generating with [MkDocs](https://www.mkdocs.org/) and [Material MkDocs](https://squidfunk.github.io/mkdocs-material/) a documentation respecting the dirs and files hierarchy. The stuff documented for each file are listed below:

  - Imports `[ast.Import | ast.ImportFrom]`

    - [x] Type `[Native | TrdParty | Local]`
    - [x] Path (e.g. 'django.http')
    - [x] Code

  - Constants `[ast.Assign | ast.AnnAssign]`

    - [x] Name (token name)
    - [x] Typing Notation (datatype)
    - [x] Value (literal or call)
    - [x] Code

  - Classes `[ast.ClassDef]`

    - [ ] Description (docstring)
    - [x] Name (class name)
    - [x] Parents (inheritance)
    - [ ] Methods Defined (nums and names)
    - [ ] Example (usage)
    - [x] Code

  - Funcs `[ast.FunctionDef | ast.AsyncFunctionDef]`

    - [ ] Description (docstring)
    - [x] Name (func name)
    - [ ] Type `[Func | Method | Generator | Coroutine]`
    - [x] Parameters (name, type, default)
    - [x] Return Type (datatype)
    - [ ] Raises (exception throw)
    - [ ] Example (usage)
    - [x] Code

  - Assertions `[ast.Assert]`

    - [x] Test (assertion by itself)
    - [x] Message (opt. message in fail case)
    - [x] Code



  ![Python](https://img.shields.io/badge/Python-blue?style=for-the-badge&logo=python&logoColor=ffd43b)

  ![uv](https://img.shields.io/badge/uv-2b0231?style=for-the-badge&logo=uv)
  ![Ruff](https://img.shields.io/badge/Ruff-2b0231?style=for-the-badge&logo=ruff)
  ![Material for MkDocs](https://img.shields.io/badge/Material%20for%20MkDocs-fff?style=for-the-badge&logo=material-for-mkdocs&logoColor=526cfe)

  ![GitHub](https://img.shields.io/badge/GitHub-fff?style=for-the-badge&logo=github&logoColor=181717)
  ![GitHub Pages](https://img.shields.io/badge/GitHub%20Pages-fff?style=for-the-badge&logo=github-pages&logoColor=222222)
  ![GitHub Actions](https://img.shields.io/badge/GitHub%20Actions-2088ff?style=for-the-badge&logo=github-actions&logoColor=fff)



  - [ ] Evaluate use of Rust for better proccessing
  - [ ] Evaluate the processing of more files than just Python ones (e.g. `.txt`, `.toml`)
  - [x] Migrate dependency system to use [uv](https://docs.astral.sh/uv/)
  - [x] Process 25% of Python [AST](https://docs.python.org/3/library/ast.html)'s nodes on `mosheh.handler`
  - [x] Process 50% of Python [AST](https://docs.python.org/3/library/ast.html)'s nodes on `mosheh.handler`
  - [x] Process 75% of Python [AST](https://docs.python.org/3/library/ast.html)'s nodes on `mosheh.handler`
  - [x] Process 100% of Python [AST](https://docs.python.org/3/library/ast.html)'s nodes on `mosheh.handler`
  - [ ] Accept structured file (e.g. `mosheh.json`) as parameters replacement
  - [ ] Provide an "exclude" config for files/dirs to ignore
  - [ ] Insert `tags` for `.md` based on their names/contexts
  - [ ] Get and list all metrics of above's statements featured
  - [ ] Check for files docstrings and write below filepath
  - [ ] Create detail page for classes with docstring and listing class constants and methods
  - [ ] Create detail page for functions with docstring and body detail



  Mosheh's architecture can be interpreted in two ways: the directory structure and the interaction of the elements that make it up. A considerable part of a project is - or at least should be - that elements that are dispensable for its functionality are in fact dispensable, such as the existence of automated tests; they are important so that any existing quality process is kept to a minimum acceptable level, but if all the tests are deleted, the tool still works.

  Here it is no different, a considerable part of Mosheh is, in fact, completely dispensable; follow below the structure of directories and relevant files that are part of this project:

  ```sh
  .
  ├── mosheh                      # Mosheh's source-code
  │   ├── codebase.py             # Codebase reading logic
  │   ├── constants.py            # Constants to be evaluated
  │   ├── custom_types.py         # Custom data types
  │   ├── doc.py                  # Documentation build logic
  │   ├── handlers.py             # Codebase nodes handlers functions
  │   ├── main.py                 # Entrypoint
  │   ├── metadata.py             # Metadata about Mosheh itself
  │   └── utils.py                # Utilities
  │
  ├── tests                       # Template dir for testing
  │   ├── DOC                     # Doc output dir
  │   ├── PROJECT                 # Template project dir
  │   └── unittest                # Automated tests
  │
  ├── documentation               # Mosheh's documentation dir
  │   ├── docs                    # Dir containing .md files and assets
  │   └── mkdocs.yml              # MkDocs config file
  │
  ├── pyproject.toml              # Mosheh's config file for almost everything
  ├── uv.lock                     # uv's lockfile for dealing with dependencies
  ├── .python-version             # Default Python's version to use
  │
  ├── .github                     # Workflows and social stuff
  │
  ├── LICENSE                     # Legal stuf, A.K.A donut sue me
  │
  └── .gitignore                  # Git "exclude" file
  ```

  It is to be expected that if the `tests/` directory is deleted, Mosheh itself will not be altered in any way, so much so that when a tool is downloaded via `pip` or similar, the tool is not accompanied by tests, licenses, development configuration files or workflows. So, to help you understand how the `mosheh/` directory works, here's how the functional elements interact with each other:

  ![Flowchart diagram](https://raw.githubusercontent.com/lucasGoncSilva/mosheh/refs/heads/main/.github/flowchart.svg)







  ```sh
  pip install uv  # For installing uv to handle the environment

  uv sync  # Automatically creates a .venv, activates it and install libs based on uv.lock and pyproject.toml
  ```



  ```sh
  uv run -m mosheh.main  # For running using uv and dealing with Mosheh as a module
  ```



  ```sh
  uv build  # Build pip-like file

  uv pip install dist/mosheh-<VERSION>-py3-none-any.whl --force-reinstall  # Install Mosheh using generated pip-like file
  ```



  ```sh
  uv run pytest  # Run pytest
  ```



  |      Call       |  Type  | Mandatory  | Default                          | Example                         | Description                                                      |
  | :-------------: | :----: | :--------: | :------------------------------- | :------------------------------ | :--------------------------------------------------------------- |
  | `-h`, `--help`  | `str`  | `Optional` | `None`                           | `-h`, `--help`                  | Help message                                                     |
  |     `-root`     | `Path` | `Required` | `None`                           | `-root example/`                | Root dir, where the analysis starts.                             |
  |  `--repo-name`  | `str`  | `Optional` | `'GitHub'`                       | `--repo-name toicin`            | Name of the code repository to be mapped.                        |
  |  `--repo-url`   | `URL`  | `Optional` | `'https://github.com/'`          | `--repo-url https://random.com` | URL of the code repository to be mapped.                         |
  |  `--edit-uri`   | `str`  | `Optional` | `'blob/main/documentation/docs'` | `--edit-uri blob/main/docs`     | URI to view raw or edit blob file.                               |
  |  `--logo-path`  | `Path` | `Optional` | `None`                           | `--repo-url .github/logo.svg`   | Path for doc/project logo, same Material MkDocs's formats.       |
  | `--readme-path` | `Path` | `Optional` | `None`                           | `--repo-url .github/README.md`  | Path for `README.md` file to used as homepage.                   |
  |   `--verbose`   | `int`  | `Optional` | `3` - `logging.INFO`             | `--verbose 4`                   | Verbosity level, from 0 (quiet/critical) to 4 (overshare/debug). |
  |   `--output`    | `Path` | `Optional` | `'.'` - current dir              | `--output doc/`                 | Path for documentation output, where to be created.              |



  This project is under [MIT License](https://choosealicense.com/licenses/mit/). A short and simple permissive license with conditions only requiring preservation of copyright and license notices. Licensed works, modifications, and larger works may be distributed under different terms and without source code.

rpm_license:
  MIT License  Copyright (c) 2024 Lucas Gonçalves da Silva  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: 16e8d3828e3024fb3b9d396deeab422d1613c194bfc4f5cda15547a95f734eea
name: python-mosip-auth-sdk-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for mosip-auth-sdk
url: https://pypi.org/project/mosip-auth-sdk/
rpm_license: Mozilla Public License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mosip-auth-sdk-0.5.3-1.src.rpm
location_href: Packages/python-mosip-auth-sdk-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  MOSIP Authentication SDK is a Python wrapper for interacting with the MOSIP Authentication Service, enabling developers to integrate authentication workflows into their systems. The SDK simplifies the interaction with MOSIP's backend authentication services, providing methods to authenticate individuals based on demographic data, biometrics, and other identifiers.



  MOSIP provides two main authentication controllers:

  1. **kyc-auth-controller**
     Used for Know Your Customer (KYC) authentication, which includes verifying identity using demographic data and biometrics.
     [API Documentation](https://mosip.github.io/documentation/1.2.0/authentication-service.html#tag/kyc-auth-controller)

  2. **auth-controller**
     Used for general authentication of individuals, allowing for verification based on a variety of identifiers and biometric data.
     [API Documentation](https://mosip.github.io/documentation/1.2.0/authentication-service.html#operation/authenticateIndividual)





  ```python
  kyc(individual_id: str, individual_id_type: str, demographic_data: DemographicsModel, otp_value: str = None, biometrics: list[BiometricModel] = None, consent: bool = False) -> Response
  ```



  ```python
  auth(individual_id: str, individual_id_type: str, demographic_data: DemographicsModel, otp_value: Optional[str] = None, biometrics: Optional[List[BiometricModel]] = None, consent: bool = False) -> Response
  ```



  - **individual_id (str)**: The unique ID of the individual to authenticate (e.g., VID, UIN)
  - **individual_id_type (str)**: The type of the ID being used (e.g., VID, UIN)
  - **demographic_data (DemographicsModel)**: The demographic data for the individual (e.g., name, address)
  - **otp_value (Optional[str])**: The One-Time Password (OTP) value, if applicable (default is None)
  - **consent (bool)**: Indicates whether consent has been obtained for authentication (default is False)



  ```bash
  pip install mosip_auth_sdk
  ```



  ```python
  from mosip_auth_sdk import MOSIPAuthenticator
  from mosip_auth_sdk.models import DemographicsModel, BiometricModel


  authenticator = MOSIPAuthenticator(config={
      
      
  })


  demographics_data = DemographicsModel(
      
  )


  response = authenticator.kyc(
      individual_id='<some_id>',  # Replace with actual ID
      individual_id_type='VID',  # Replace with the type of ID being used
      demographic_data=demographics_data,
      otp_value='<otp_value>',  # Optional
      biometrics=biometrics,  # Optional
      consent=True  # Indicates if consent has been obtained
  )


  response_body = response.json()
  errors = response_body.get('errors', [])

  if errors:
      
      pass
  else:
      
      decrypted_response = authenticator.decrypt_response(response_body)
      
  ```




  - Python 3 (tested on 3.10.7)
  - Poetry (recommended, optional)


  ```bash
  python3 -m pip install poetry
  ```


  Using Poetry:
  ```bash
  python3 -m poetry install
  ```

  Using pip:
  ```bash
  python3 -m pip install -r requirements.txt
  ```


  ```bash
  python3 -m poetry build
  ```


  ```bash
  python3 -m poetry publish
  ```



  Example code is available in the `examples` folder. To test:

  ```bash
  python examples/main.py
  ```


pkgId: 6edf4e5416c8be9577b03e1447ba5f6bafc1872ffe4ef5029a42c9fe26fa4a3c
name: python-mosparo-api-client-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for mosparo-api-client
url: https://pypi.org/project/mosparo-api-client/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mosparo-api-client-1.1.2-1.src.rpm
location_href: Packages/python-mosparo-api-client-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  This Python library lets you connect to a mosparo installation and verify the submitted data.


  Install this library by using pip:
  ```text
  pip install mosparo-api-client
  ```

  You need the module `build` to build the module from source.
  1. Clone the repository
  2. Build the package
  ```commandline
  python -m build
  ```
  3. Install the package
  ```commandline
  pip install dist/mosparo_api_client-1.0.0-py3-none-any.whl
  ```

  1. Create a project in your mosparo installation
  2. Include the mosparo script in your form
  ```html
  <div id="mosparo-box"></div>
  <script src="https://[URL]/build/mosparo-frontend.js" defer></script>
  <script>
      var m;
      window.onload = function(){
          m = new mosparo('mosparo-box', 'https://[URL]', '[UUID]', '[PUBLIC_KEY]', {loadCssResource: true});
      };
  </script>
  ```
  3. Include the library in your project
  ```text
  pip install mosparo-api-client
  ```
  4. After the form is submitted, verify the data before processing it
  ```python
  from mosparo_api_client import Client
  api_client = Client(host, public_key, private_key)
  your_post_data = {}  # This needs to be filled with the post data
  mosparo_submit_token = your_post_data['_mosparo_submitToken']
  mosparo_validation_token = your_post_data['_mosparo_validationToken']
  result = api_client.verify_submission(your_post_data, mosparo_submit_token, mosparo_validation_token)
  if result.is_submittable():
      
      pass
  else:
      
      pass
  ```



  Create a new client object to use the API client.
  ```python
  from mosparo_api_client import Client
  api_client = Client(host, public_key, private_key, verify_ssl)
  ```
  | Parameter   | Type | Description                                                 |
  |-------------|------|-------------------------------------------------------------|
  | host        | str  | The host of the mosparo installation                        |
  | public_key  | str  | The public key of the mosparo project                       |
  | private_key | str  | The private key of the mosparo project                      |
  | verify_ssl  | bool | Set to False if the SSL certificate should not be verified. |

  To verify the form data, call `verify_submission` with the form data in an array and the submit and validation tokens, which mosparo generated on the form initialization and the form data validation. The method will return a `VerificationResult` object.
  ```python
  result = api_client.verify_submission(form_data, mosparo_submit_token, mosparo_validation_token)
  ```
  | Parameter                | Type  | Description                                                                                                  |
  |--------------------------|-------|--------------------------------------------------------------------------------------------------------------|
  | form_data                | dict  | The dictionary with all the submitted form data.                                                             |
  | mosparo_submit_token     | str   | The submit token which was generated by mosparo and submitted with the form data                             |
  | mosparo_validation_token | str   | The validation token which mosparo generated after the validation and which was submitted with the form data |

  After the verification of the submission by mosparo, you have to verify that all required fields and all possible fields were verified correctly. For this you have to check that all your required fields are set in the result ([get_verified_fields](#get_verified_fields-list-see-constants)).
  See [Bypass protection](https://documentation.mosparo.io/docs/integration/bypass_protection) in the mosparo documentation.

  ```python
  verified_fields = result.get_verified_fields()
  required_field_difference = set(list_of_required_field_names) - set(verified_fields.keys())
  verifiable_field_difference = set(list_of_verifiable_field_names) - set(verified_fields.keys())

  if result.is_submittable() and not required_field_difference and not verifiable_field_difference:
      print('All good, send email')
  else:
      raise Exception('mosparo did not verify all required fields. This submission looks like spam.')
  ```
  `list_of_required_field_names` and `list_of_verifiable_field_names` contain the names of all required or verifiable fields. Verifiable fields are fields that mosparo can validate and verify (for example, text fields). A checkbox field, for example, will not be validated and verified by mosparo.


  - `FIELD_NOT_VERIFIED`: 'not-verified'
  - `FIELD_VALID`: 'valid'
  - `FIELD_INVALID`: 'invalid'

  Returns `True` if the form is submittable. This means that the verification was successful and the
  form data are valid.

  Returns `True` if mosparo determined the form as valid. The difference to `is_submittable()` is, that this
  is the original result from mosparo, while `is_submittable()` also checks if the verification was done correctly.

  Returns an array with all verified field keys.

  Returns the verification status of one field.

  Returns `True` if there were verification issues.

  Returns an array with all verification issues.

  To get the statistic data grouped by date, call `get_statistic_by_date`. The method accepts a time range in seconds for which the data should be returned (last x seconds) or the start date from which the data should be returned. The method will return a `StatisticResult` object.
  ```python
  result = api_client.get_statistic_by_date(range, start_date)
  ```
  | Parameter  | Type          | Description                                                                         |
  |------------|---------------|-------------------------------------------------------------------------------------|
  | range      | int           | Time range in seconds (will be rounded up to a full day since mosparo v1.1)         |
  | start_date | datetime.date | The start date from which the statistics are to be returned (requires mosparo v1.1) |


  Return the number of valid submissions in the requested time range.

  Return the number of spam submissions in the requested time range.

  Return the numbers grouped by date.

  mosparo Python API Client is open-sourced software licensed under the [MIT License](https://opensource.org/licenses/MIT).
  Please see the [LICENSE](LICENSE) file for the full license.

rpm_license:
  The MIT License (MIT)  Copyright 2023-2024 mosparo Core Developers and contributors  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: 60a1a29c3955976db46ab8067e1c8c2403d794f045cfa9a6be5ce6194b497e24
name: python-mosparo-django-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for mosparo-django
url: https://pypi.org/project/mosparo-django/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mosparo-django-1.0.3-1.src.rpm
location_href: Packages/python-mosparo-django-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  With this Django app, you can protect your forms with mosparo. Install the app, configure it and add the field to your forms.

  Please see our [How to use](https://mosparo.io/how-to-use/) introduction on our website to learn how to use mosparo in your form.
  In step 3 of the how-to-use explanation, you must integrate mosparo into your website. Please follow the [Installation](#installation) part below for this process.
  In step 4 of the how-to-use explanation, you must connect your website with your mosparo project. Please follow the [Usage](#usage) part below.


  Install this app by using pip:
  ```commandline
  pip install mosparo_django
  ```

  You need the module `build` to build the module from source.
  1. Clone the repository
  2. Build the package
  ```commandline
  python -m build
  ```
  3. Install the package
  ```commandline
  pip install dist/mosparo_django-1.0.2-py3-none-any.whl
  ```

  1. Create a project in your mosparo installation
  2. Edit the `settings.py` file of your project
  2. Add the mosparo integration to the list of enabled apps:
  ```python
  INSTALLED_APPS = [
      
      'mosparo_django',
  ]
  ```
  3. Specify the configuration for mosparo:
  ```python
  MOSPARO_HOST = 'https://...'
  MOSPARO_UUID = '...'
  MOSPARO_PUBLIC_KEY = '...'
  MOSPARO_PRIVATE_KEY = '...'
  MOSPARO_VERIFY_SSL = True
  ```
  4. Add the mosparo field to your form:
  ```python
  from mosparo_django.fields import MosparoField
  class Form(forms.Form):
      
      mosparo = MosparoField(label='Spam protection')
  ```
  5. Add the verification (see [Verification](#verification))
  6. Test your form and verify that everything works correctly and you see the submission in mosparo.

  After the user submits the form, the backend has to verify the form data before you can process them. Since we didn't find a good way to do this automatically, you have to implement one of the following options:

  Use the mosparo Form class to create your form instead of the `django.forms.Form` class:
  ```python
  from mosparo_django.forms import MosparoForm
  from mosparo_django.fields import MosparoField
  class Form(MosparoForm):
      
      mosparo = MosparoField(label='Spam protection')
  ```

  The other option is to override the method `clean` of the Form class:
  ```python
  from mosparo_django.fields import MosparoField
  class Form(forms.Form):
      
      mosparo = MosparoField(label='Spam protection')
      def clean(self):
          self.fields['mosparo'].verify_data(self)
          return super().clean()
  ```
  **Important: No spam protection will happen if you do not use one of these two things.**

  You can also specify the connection details on the field. For that, please add the field to your form and specify the connection settings by setting the parameters `mosparo_host`, `mosparo_uuid`, `mosparo_public_key`, `mosparo_private_key`, and `mosparo_verify_ssl`. If you want to change the UUID, public or private key, you have to specify all these three values because these depend on the project and if you want to connect the field to a different project, all three values will be different.
  ```python
  from mosparo_django.forms import MosparoForm
  from mosparo_django.fields import MosparoField
  class Form(MosparoForm):
      
      mosparo = MosparoField(label='Spam protection', mosparo_uuid='123', mosparo_public_key='test_key', mosparo_private_key = 'private_key')
  ```

  The MosparoField offers some callback methods to adjust the behavior of the field.
  ```python
  from mosparo_django.forms import MosparoForm
  from mosparo_django.fields import MosparoField
  class Form(MosparoForm):
      
      mosparo = MosparoField(callback_ignored_field_types=None, callback_verifiable_field_types=None, callback_after_prepare_form_data=None)
  ```
  | Argument name                      | Description                                                                                                                                          |
  |------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `callback_ignored_field_types`     | Gets and returns a list of class names of field types, which should be ignored (Example: `PasswordInput`)                                            |
  | `callback_verifiable_field_types`  | Gets and returns a list of class names of field types, which are verifiable (Example: `TextInput`)                                                   |
  | `callback_after_prepare_form_data` | Gets the dict with all prepared form data, the required field names, and the verifiable field names as argument and expects the same to be returned. |

  mosparo Integration for Django is open-sourced software licensed under the [MIT License](https://opensource.org/licenses/MIT).
  Please see the [LICENSE](LICENSE) file for the full license.

rpm_license:
  The MIT License (MIT)  Copyright 2023-2024 mosparo Core Developers and contributors  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: daf695a489f21746ea54fd79097a512b383ffc0c0ef03f78f2cb09701905516a
name: python-mosqlient-help
arch: noarch
version: 1.7.1
epoch: 0
release: 1
summary: Development documents and examples for mosqlient
url: https://github.com/Mosqlimate-project/mosqlimate-client
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mosqlient-1.7.1-1.src.rpm
location_href: Packages/python-mosqlient-help-1.7.1-1.noarch.rpm
checksum_type: sha256
description:
  [![ci](https://github.com/Mosqlimate-project/mosqlimate-client/workflows/ci/badge.svg)](https://github.com/Mosqlimate-project/mosqlimate-client/actions?query=workflow%3Aci)
  [![documentation](https://img.shields.io/badge/docs-mkdocs%20material-blue.svg?style=flat)](https://api.mosqlimate.org/docs/)
  [![pypi version](https://img.shields.io/pypi/v/mosqlimate-client.svg)](https://pypi.org/project/mosqlient)
  [![gitter](https://badges.gitter.im/join%20chat.svg)](https://gitter.im/mosqlimate-client/community)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  client library for the Mosqlimate project data platform.



  Mosqlimate client requires Python 3.10 or above.





  ```bash
  pip install mosqlient
  ```


  Despite `mosqlient` being a Python library, it can be used from R using the `reticulate` package. Here is an example of how to use `mosqlient` from R:

  In the examples folder, you can find an [R jupyter notebook](/examples/Using%20Mosqlient%20from%20R.ipynb) of how to use `mosqlient` from R.


pkgId: b7e8ab869d3753224749b144b8cec484392b8127bc420668774ff444db10bc9c
name: python-moss_geoio_sdk-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for moss_geoio_sdk
url: https://www.moss.de/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moss_geoio_sdk-0.1.9-1.src.rpm
location_href: Packages/python-moss_geoio_sdk-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  This is the Python SDK to interact with [M.O.S.S. Computer Grafik Systeme GmbH](https://www.moss.de/wega/) GeoIO



  This package kann be installed using pip

  ```shell
  python -m pip install moss_geoio_sdk
  ```



  ```python
  from moss.geoio_sdk.geoio_service import GeoIO
  from moss.geoio_sdk.model.user import User

  user_name = "username"
  user_password = "password"
  geoIO_url = "https://geoio.server.your.domain:8443/mcm-geoio"

  my_logger = logging.getLogger("my_logger")
  logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
  geoIO = GeoIO(
      geoIO_url, user_name, user_password, Path("c:/temp/geoio_sdk"), my_logger
  )
  ```


pkgId: 050b2d10bde748953e9f0b69f51ad0754b97dd91b0b2758d985de67910d8a245
name: python-mostlyai-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for mostlyai
url: https://app.mostly.ai/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mostlyai-0.5.0-1.src.rpm
location_href: Packages/python-mostlyai-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/docs-latest-green)](https://mostly-ai.github.io/mostlyai-client/) [![stats](https://pepy.tech/badge/mostlyai)](https://pypi.org/project/mostlyai/) ![license](https://img.shields.io/github/license/mostly-ai/mostlyai-client) ![GitHub Release](https://img.shields.io/github/v/release/mostly-ai/mostlyai-client) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mostlyai)

  The official Python client for [MOSTLY AI](https://app.mostly.ai/), the #1 platform for high-fidelity, privacy-safe **Synthetic Data**.

  The client allows you to programmatically create, browse and manage the 3 key resources of the MOSTLY AI platform:

  1. **Generators** - Train a synthetic data generator on your existing tabular or language data assets
  2. **Synthetic Datasets** - Use a generator to create any number of synthetic samples to your needs
  3. **Connectors** - Connect to any data source within your organization, for reading and writing data


  | Intent                                        | Primitive                         |
  |-----------------------------------------------|-----------------------------------|
  | Train a Generator on tabular or language data | `g = mostly.train(config)`        |
  | Generate any number of synthetic data records | `sd = mostly.generate(g, config)` |
  | Live probe the generator on demand            | `df = mostly.probe(g, config)`    |
  | Connect to any data source within your org    | `c = mostly.connect(config)`      |

  See also our [Platform Documentation](https://mostly.ai/docs) for detailed feature descriptions and further Python examples.



  The latest release of `mostlyai` can be installed via pip:

  ```shell
  pip install -U mostlyai
  ```



  Please obtain your personal API key from your [account settings page](https://app.mostly.ai/settings/api-keys), and adjust the following code snippet, before running it.

  ```python
  import pandas as pd
  from mostlyai import MostlyAI


  mostly = MostlyAI(
      api_key='INSERT_YOUR_API_KEY',   # or set env var `MOSTLYAI_API_KEY`
      base_url='https://app.mostly.ai' # or set env var `MOSTLYAI_BASE_URL`
  )


  df_original = pd.read_csv('https://github.com/mostly-ai/public-demo-data/raw/dev/census/census.csv.gz')
  g = mostly.train(name='census', data=df_original)  # shorthand syntax for 1-table config


  df_samples = mostly.probe(g, size=10)


  sd = mostly.generate(g, size=10_000)


  df_synthetic = sd.data()
  ```



  * [MOSTLY AI Website](https://mostly.ai/)
  * [MOSTLY AI Blog](https://mostly.ai/blog)
  * [Platform Documentation](https://mostly.ai/docs)
  * [OpenAPI Documentation](https://api-docs.mostly.ai/)
  * [MOSTLY AI @ GitHub](https://github.com/mostly-ai/)
  * [Synthetic Data - Quality Assurance](https://github.com/mostly-ai/mostlyai-qa/) `mostlyai-qa`


pkgId: 8573cfb5ee4435129f2476bec5561cef2800a671cb1cf67c6bcaceeb55575f0f
name: python-mostlyai-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for mostlyai
url: https://app.mostly.ai/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mostlyai-0.7.0-1.src.rpm
location_href: Packages/python-mostlyai-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/docs-latest-green)](https://mostly-ai.github.io/mostlyai/) [![stats](https://pepy.tech/badge/mostlyai)](https://pypi.org/project/mostlyai/) ![license](https://img.shields.io/github/license/mostly-ai/mostlyai) ![GitHub Release](https://img.shields.io/github/v/release/mostly-ai/mostlyai) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mostlyai)

  [Package Documentation](https://mostly-ai.github.io/mostlyai/) | [Platform Documentation](https://mostly.ai/docs) | [Usage Examples](https://mostly-ai.github.io/mostlyai/api_client/)

  The official Python SDK for [MOSTLY AI](https://app.mostly.ai/), the #1 platform for high-fidelity privacy-safe **Synthetic Data**.

  This toolkit allows you to programmatically create, browse and manage the 3 key resources of the MOSTLY AI platform:

  1. **Generators** - Train a synthetic data generator on your existing tabular or language data assets
  2. **Synthetic Datasets** - Use a generator to create any number of synthetic samples to your needs
  3. **Connectors** - Connect to any data source within your organization, for reading and writing data


  | Intent                                        | Primitive                         | Documentation                                                                                                 |
  |-----------------------------------------------|-----------------------------------|---------------------------------------------------------------------------------------------------------------|
  | Train a Generator on tabular or language data | `g = mostly.train(config)`        | see [mostly.train](https://mostly-ai.github.io/mostlyai/api_client/#mostlyai.client.api.MostlyAI.train)       |
  | Generate any number of synthetic data records | `sd = mostly.generate(g, config)` | see [mostly.generate](https://mostly-ai.github.io/mostlyai/api_client/#mostlyai.client.api.MostlyAI.generate) |
  | Live probe the generator on demand            | `df = mostly.probe(g, config)`    | see [mostly.probe](https://mostly-ai.github.io/mostlyai/api_client/#mostlyai.client.api.MostlyAI.probe)       |
  | Connect to any data source within your org    | `c = mostly.connect(config)`      | see [mostly.connect](https://mostly-ai.github.io/mostlyai/api_client/#mostlyai.client.api.MostlyAI.connect)   |



  The latest release of `mostlyai` can be installed via pip:

  ```shell
  pip install -U mostlyai
  ```



  Please obtain your personal API key from your [account settings page](https://app.mostly.ai/settings/api-keys), and adjust the following code snippet, before running it.

  ```python
  import pandas as pd
  from mostlyai import MostlyAI


  mostly = MostlyAI(
      api_key='INSERT_YOUR_API_KEY',   # or set env var `MOSTLYAI_API_KEY`
      base_url='https://app.mostly.ai' # or set env var `MOSTLYAI_BASE_URL`
  )


  df_original = pd.read_csv('https://github.com/mostly-ai/public-demo-data/raw/dev/census/census.csv.gz')
  g = mostly.train(name='census', data=df_original)  # shorthand syntax for 1-table config


  df_samples = mostly.probe(g, size=10)


  sd = mostly.generate(g, size=10_000)


  df_synthetic = sd.data()
  ```



  * [MOSTLY AI Website](https://mostly.ai/)
  * [MOSTLY AI Blog](https://mostly.ai/blog)
  * [Platform Documentation](https://mostly.ai/docs)
  * [OpenAPI Documentation](https://api-docs.mostly.ai/)
  * [MOSTLY AI @ GitHub](https://github.com/mostly-ai/)
  * [Synthetic Data - Quality Assurance](https://github.com/mostly-ai/mostlyai-qa/) `mostlyai-qa`



  Please consider citing our project if you find it useful:

  ```bibtex
  @software{mostlyai,
      author = {{MOSTLY AI}},
      title = {{MOSTLY AI SDK}},
      url = {https://github.com/mostly-ai/mostlyai},
      year = {2024}
  }
  ```


pkgId: 77b99542ce0c320505e4a9b49bb778a591e4f0d963b7af125e323fd49adf9510
name: python-mostlyai-qa-help
arch: noarch
version: 1.3.5
epoch: 0
release: 1
summary: Development documents and examples for mostlyai-qa
url: https://github.com/mostly-ai/mostlyai-qa
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mostlyai-qa-1.3.5-1.src.rpm
location_href: Packages/python-mostlyai-qa-help-1.3.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/docs-latest-green)](https://mostly-ai.github.io/mostlyai-qa/) [![stats](https://pepy.tech/badge/mostlyai-qa)](https://pypi.org/project/mostlyai-qa/) ![license](https://img.shields.io/github/license/mostly-ai/mostlyai-qa) ![GitHub Release](https://img.shields.io/github/v/release/mostly-ai/mostlyai-qa) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mostlyai-qa)

  [Documentation](https://mostly-ai.github.io/mostlyai-qa/) | [Sample Reports](#sample-reports) | [Technical White Paper](https://raw.githubusercontent.com/mostly-ai/mostlyai-qa/refs/heads/main/docs/mostlyai-qa-technical-white-paper.pdf)

  Assess the fidelity and novelty of synthetic samples with respect to original samples:

  1. calculate a rich set of accuracy, similarity and distance metrics
  2. visualize statistics for easy comparison to training and holdout samples
  3. generate a standalone, easy-to-share, easy-to-read HTML summary report

  ...all with a few lines of Python code 💥.



  The latest release of `mostlyai-qa` can be installed via pip:

  ```bash
  pip install -U mostlyai-qa
  ```

  The latest development version can be installed directly from GitHub:

  ```bash
  pip install -U git+https://github.com/mostly-ai/mostlyai-qa.git@main
  ```



  ```python
  import pandas as pd
  import webbrowser
  from mostlyai import qa


  base_url = "https://github.com/mostly-ai/mostlyai-qa/raw/refs/heads/main/examples/quick-start"
  syn = pd.read_csv(f"{base_url}/census2k-syn_mostly.csv.gz")

  trn = pd.read_csv(f"{base_url}/census2k-trn.csv.gz")
  hol = pd.read_csv(f"{base_url}/census2k-hol.csv.gz")


  report_path, metrics = qa.report(
      syn_tgt_data=syn,
      trn_tgt_data=trn,
      hol_tgt_data=hol,
  )


  print(metrics.model_dump_json(indent=4))


  webbrowser.open(f"file://{report_path.absolute()}")
  ```



  ```python
  from mostlyai import qa


  report_path, metrics = qa.report(
      syn_tgt_data = synthetic_df,
      trn_tgt_data = training_df,
      hol_tgt_data = holdout_df,  # optional
  )


  report_path, metrics = qa.report(
      syn_tgt_data = synthetic_df,
      trn_tgt_data = training_df,
      hol_tgt_data = holdout_df,  # optional
      tgt_context_key = "user_id",
  )


  report_path, metrics = qa.report(
      syn_tgt_data = synthetic_df,
      trn_tgt_data = training_df,
      hol_tgt_data = holdout_df,  # optional
      syn_ctx_data = synthetic_context_df,
      trn_ctx_data = training_context_df,
      hol_ctx_data = holdout_context_df,  # optional
      ctx_primary_key = "id",
      tgt_context_key = "user_id",
  )
  ```



  * [Baseball Players](https://html-preview.github.io/?url=https://github.com/mostly-ai/mostlyai-qa/blob/main/examples/baseball-players.html) (Flat Data)
  * [Baseball Seasons](https://html-preview.github.io/?url=https://github.com/mostly-ai/mostlyai-qa/blob/main/examples/baseball-seasons-with-context.html) (Sequential Data)



  Please consider citing our project if you find it useful:

  ```bibtex
  @software{mostlyai-qa,
      author = {{MOSTLY AI}},
      title = {{MOSTLY AI - Quality Assurance}},
      url = {https://github.com/mostly-ai/mostlyai-qa},
      year = {2024}
  }
  ```


pkgId: def56e6d7ee5de1338def5e4b63af119dc4f25308a5743e9cf452469f1b23361
name: python-moto-help
arch: noarch
version: 5.0.23
epoch: 0
release: 1
summary: Development documents and examples for moto
url: https://github.com/getmoto/moto
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moto-5.0.23-1.src.rpm
location_href: Packages/python-moto-help-5.0.23-1.noarch.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/awsmoto/Lobby](https://badges.gitter.im/awsmoto/Lobby.svg)](https://gitter.im/awsmoto/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  [![Build Status](https://github.com/getmoto/moto/workflows/TestNDeploy/badge.svg)](https://github.com/getmoto/moto/actions)
  [![Coverage Status](https://codecov.io/gh/getmoto/moto/branch/master/graph/badge.svg)](https://codecov.io/gh/getmoto/moto)
  [![Docs](https://readthedocs.org/projects/pip/badge/?version=stable)](http://docs.getmoto.org)
  [![PyPI](https://img.shields.io/pypi/v/moto.svg)](https://pypi.org/project/moto/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/moto.svg)](#)
  [![PyPI - Downloads](https://img.shields.io/pypi/dw/moto.svg)](https://pypistats.org/packages/moto)
  [![Code style: 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)
  [![Financial Contributors](https://opencollective.com/moto/tiers/badge.svg)](https://opencollective.com/moto)




  ```console
  $ pip install 'moto[ec2,s3,all]'
  ```




  Moto is a library that allows your tests to easily mock out AWS Services.

  Imagine you have the following python code that you want to test:

  ```python
  import boto3


  class MyModel:
      def __init__(self, name, value):
          self.name = name
          self.value = value

      def save(self):
          s3 = boto3.client("s3", region_name="us-east-1")
          s3.put_object(Bucket="mybucket", Key=self.name, Body=self.value)
  ```

  Take a minute to think how you would have tested that in the past.

  Now see how you could test it with Moto:

  ```python
  import boto3
  from moto import mock_aws
  from mymodule import MyModel


  @mock_aws
  def test_my_model_save():
      conn = boto3.resource("s3", region_name="us-east-1")
      
      conn.create_bucket(Bucket="mybucket")
      model_instance = MyModel("steve", "is awesome")
      model_instance.save()
      body = conn.Object("mybucket", "steve").get()["Body"].read().decode("utf-8")
      assert body == "is awesome"
  ```

  With the decorator wrapping the test, all the calls to s3 are automatically mocked out. The mock keeps track of the state of the buckets and keys.

  For a full list of which services and features are covered, please see our [implementation coverage](https://github.com/getmoto/moto/blob/master/IMPLEMENTATION_COVERAGE.md).



  The full documentation can be found here:

  [http://docs.getmoto.org/en/latest/](http://docs.getmoto.org/en/latest/)



  Support this project and its continued development, by sponsoring us!

  Click the `Sponsor`-button at the top of the page for more information.

  Our finances are managed by OpenCollective, which means you have full visibility into all our contributions and expenses:
  https://opencollective.com/moto



  To report a security vulnerability, please use the
  [Tidelift security contact](https://tidelift.com/security).
  Tidelift will coordinate the fix and disclosure.


pkgId: 2180bf883f4753121100b8773f6b07bbdacc1d598ae0d3a8a7f725206f66db52
name: python-moulti-help
arch: noarch
version: 1.23.2
epoch: 0
release: 1
summary: Development documents and examples for moulti
url: https://github.com/xavierog/moulti
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-moulti-1.23.2-1.src.rpm
location_href: Packages/python-moulti-help-1.23.2-1.noarch.rpm
checksum_type: sha256
description:
  Moulti changes the way your shell scripts (bash, zsh, etc.) display their output in your terminal.
  Moulti enables you to assign the numerous lines emitted by your scripts to "steps", i.e. visual, collapsible blocks featuring their own title and color.

  Here is what [upgrading a Debian system](examples/moulti-debian-upgrade.bash) looks like with Moulti:

  ![Moulti demo: Debian upgrade (Animated PNG)](https://xavier.kindwolf.org/p/moulti/doc/img/moulti-demo-debian-upgrade.png?20240218)

  Interested? [Run this demo in a container using docker or podman](https://hub.docker.com/r/xavierong/moulti-demo)

  Not convinced yet? What if the output of your Ansible playbooks looked like this?

  ![Moulti: Ansible playbook output](https://xavier.kindwolf.org/p/moulti/doc/img/moulti-ansible.png?20240505)

  Moulti is a tool meant for people who write and execute shell scripts and/or Ansible playbooks.
  Specifically, if you find yourself scrolling up your terminal to ensure everything went fine while your script is still running, then Moulti is made for you.

  By the way, Moulti can also display man pages and unified diff files (with colors courtesy of [delta](https://github.com/dandavison/delta)):

  ![Moulti: man page](https://xavier.kindwolf.org/p/moulti/doc/img/moulti-man-bash.png?20240621)

  ![Moulti: unified diff output](https://xavier.kindwolf.org/p/moulti/doc/img/moulti-diff.png?20240914)



  TL;DR: `pipx install moulti; pipx ensurepath`

  More details in the [Documentation](Documentation.md#installation)



  Synopsis:

  1. Start a Moulti instance: `moulti init`
  2. Add a step: `moulti step add step_name --title='some clever title here'`
  3. Fill it: `whatever_your_script_does | moulti pass step_name`
  4. Repeat #2 and #3 until your script is done.

  Learn how to leverage Moulti by jumping to its [Documentation](Documentation.md).



  As shown in the demo, Moulti enables user interactions through **questions**:

  ![Moulti input question](https://xavier.kindwolf.org/p/moulti/doc/img/moulti-input-question.png?20240218)

  ![Moulti button question](https://xavier.kindwolf.org/p/moulti/doc/img/moulti-button-question.png?20240218)

  Moulti also features:
  - text **search**, similar to `less`: [documentation](Documentation.md#text-search)
  - ability to maximize a single step log, similar to tmux's zoom feature
  - a **progress bar**: [documentation](Documentation.md#progress-bar)
  - programmatic scrolling: [documentation](Documentation.md#programmatically-scrolling-through-steps)
  - an askpass helper named `moulti-askpass`: [documentation](Documentation.md#moulti-run-dealing-with-ssh)
  - support for [Ansible playbooks](Documentation.md#moulti-run-dealing-with-ansible), [man pages](Documentation.md#moulti-manpage) and [unified diff](Documentation.md#moulti-diff)

  When it comes to look and feel, Moulti can be customised:

  - through `moulti set`: define whether Moulti steps flow up or down: [documentation](Documentation.md#multiple-ways-to-display-steps)
  - through [Textual CSS (TCSS)](https://textual.textualize.io/guide/CSS/): [documentation](Documentation.md#how-to-define-my-own-step-classes-)
  - through ANSI themes: [documentation](Documentation.md#appearance-look-and-feel)



  Moulti is written in Python and leverages [Textual](https://textual.textualize.io/), along with [Pyperclip](https://pypi.org/project/pyperclip/),
  [argcomplete](https://kislyuk.github.io/argcomplete/) and [unidiff](https://github.com/matiasb/python-unidiff).



  Moulti remained a mere idea for a significant time (possibly years).

  The idea of driving TUI elements from scripts obviously comes from tools like
  [dialog](https://invisible-island.net/dialog/dialog-figures.html) and
  [whiptail](https://whiptail.readthedocs.io/en/latest/index.html).

  At some point, the author stumbled upon
  [multiplex](https://github.com/dankilman/multiplex), which is probably the closest thing to Moulti. multiplex was deemed
  unsatisfying on multiple points (including architecture) and that prompted the development of Moulti.

  [procmux](https://github.com/napisani/procmux) is also similar to Moulti but did not affect its development.



  The Textual framework helped a lot, so kudos to the Textual team, and specifically to:
  - [Will McGugan](https://github.com/willmcgugan) for creating it
  - [Dave Pearson](https://davep.dev/) for his regular help and feedback about Textual issues


pkgId: 0cce1522a9e19b2ac4e884179f27433aa0077836d15a4d710acc4fea49457592
name: python-mousetumortrack-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for mousetumortrack
url: https://pypi.org/project/mousetumortrack/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mousetumortrack-0.0.3-1.src.rpm
location_href: Packages/python-mousetumortrack-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  ![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)


  We provide a Python package for tracking tumor nodules in mice CT scans. The project is based on [Trackpy](https://github.com/soft-matter/trackpy) and [Laptrack](https://github.com/yfukai/laptrack/tree/main) (algorithms from both libraries are implemented). It also provides a registration utility to align CT scans before tracking objects based on segmentation masks of the lungs cavity produced by the [mouselungseg](https://gitlab.com/epfl-center-for-imaging/mouselungseg) model.

  [[`Installation`](#installation)] [[`Usage`](#usage)]

  This project is part of a collaboration between the [EPFL Center for Imaging](https://imaging.epfl.ch/) and the [De Palma Lab](https://www.epfl.ch/labs/depalma-lab/).



  We recommend performing the installation in a clean Python environment. Install our package from PyPi:

  ```sh
  pip install mousetumortrack
  ```

  or from the repository:

  ```sh
  pip install git+https://github.com/EPFL-Center-for-Imaging/mousetumortrack.git
  ```

  or clone the repository and install with:

  ```sh
  git clone git+https://github.com/EPFL-Center-for-Imaging/mousetumortrack.git
  cd mousetumortrack
  pip install -e .
  ```



  Track tumor nodules from a labelled 3D timesereies array:

  ```py
  from mousetumortrack import run_tracking


  linkage_df, grouped_df, labels_timeseries_tracked = run_tracking(labels_timeseries)
  ```

  For more details, see [example.py](./scripts/example.py).



  If you encounter any problems, please file an issue along with a detailed description.



  This project is licensed under the [AGPL-3](LICENSE) license.

  This project depends on the [ultralytics](https://github.com/ultralytics/ultralytics) package which is licensed under AGPL-3.



  - [Mouse Tumor Net](https://github.com/EPFL-Center-for-Imaging/mousetumornet) | Detect tumor nodules in mice CT scans.
  - [Mouse Lungs Seg](https://github.com/EPFL-Center-for-Imaging/mouselungseg) | Detect the lungs cavity in mice CT scans.



  Special thanks go to **Sandra Gebraiel** for her contribution to the ideation and exploration of the data and for developing the preliminary code that laid the foundations for this project during the course of her lab immersion in Summer 2024.

rpm_license:
[cell repeats an earlier one in this file: 33880 characters]


pkgId: d3102a81e1da8f68ef933644abcd131040e6ccc436cb3d1de9bfdc2e9651291c
name: python-mouth2-oc-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for mouth2-oc
url: https://ouroboroscoding.com/body/mouth2
rpm_license: Custom
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mouth2-oc-2.0.0-1.src.rpm
location_href: Packages/python-mouth2-oc-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Body 2.0 service that handles outgoing communications like emails and sms messages.

  This code comes without documentation as it's not meant to be used by anyone
  outside of Ouroboros Coding Inc. Please see LICENSE for further information.


pkgId: e774962cdbef42ba04fb9d704217d7d81a17109e8714e750caa9ccdb7b4fec2e
name: python-movoid-function-help
arch: noarch
version: 1.7.4
epoch: 0
release: 1
summary: Development documents and examples for movoid-function
url: https://pypi.org/project/movoid-function/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-movoid-function-1.7.4-1.src.rpm
location_href: Packages/python-movoid-function-help-1.7.4-1.noarch.rpm
checksum_type: sha256
description:
  这个一个对函数进行各方面操作的包，包含了很多十分精妙的功能。

  这个包分了几个大的模块，分别对应了不同的函数操作小玩法



  装饰器部分包含了常见一个装饰器所需的一些辅助类的装饰器函数



  这个装饰器本质就是为了替代functools.wraps而创建的。

  它的作用和functools.wraps本质上是一样的，唯一的区别就是它在装饰了函数之后，会把函数的参数和注释全部保留，使得在运行过程中可以正确获得原函数的参数情况。




  函数是针对函数直接或间接的一些操作的功能




  替代函数，其本身是为了解决需要直接改变builtin函数的逻辑（对，就是你，print），但是又希望这个函数的变动可以随时复原，或者能自由地调用原函数地功能。

  不过现在这个函数已经被开发得可以任意替换任意包内定义的普通函数

  ```python
  from movoid_function import replace_function

  def special_print(text):
      return text

  replace_function(print, special_print)

  a = print("666") #此时不会打印任何信息，并且会给a赋值为'666'
  ```


pkgId: e1b8e6a60866dcadaa2abcd9893682de496265caa5e7f821241a38615fd69920
name: python-mp-api-help
arch: noarch
version: 0.44.0
epoch: 0
release: 1
summary: Development documents and examples for mp-api
url: https://pypi.org/project/mp-api/
rpm_license: modified BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mp-api-0.44.0-1.src.rpm
location_href: Packages/python-mp-api-help-0.44.0-1.noarch.rpm
checksum_type: sha256
description:
  [![testing](https://github.com/materialsproject/api/workflows/testing/badge.svg)](https://github.com/materialsproject/api/actions?query=workflow%3Atesting)
  [![codecov](https://codecov.io/gh/materialsproject/api/branch/main/graph/badge.svg)](https://codecov.io/gh/materialsproject/api)
  ![python](https://img.shields.io/badge/Python-3.9+-blue.svg?logo=python&amp;logoColor=white)

  This repository is the development environment for the new Materials Project API. A core client implementation will reside here. For information on how to use the API, please see the updated [documentation](https://docs.materialsproject.org/downloading-data/how-do-i-download-the-materials-project-database).


pkgId: 2f8f31862264f71bf2d80682e673d530ab6de7d16dcb7fbecd5bd22639a7a6d3
name: python-mpax-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for mpax
url: https://pypi.org/project/mpax/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpax-0.1.1-1.src.rpm
location_href: Packages/python-mpax-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/MIT-Lu-Lab/mpax/blob/main/docs/mpax.png" alt="MPAX" width="360">
  </p>



  MPAX is a hardware-accelerated, differentiable, batchable, and distributable solver for mathematical programming in JAX, designed to integrate with modern computational and deep learning workflows:

  - **Hardware accelerated**: executes on multiple architectures including CPUs, GPUs and TPUs.
  - **Differentiable**: computes derivatives of solutions with respect to inputs through implicit or unrolled differentiation.
  - **Batchable**: solves multiple problem instances of the same shape simultaneously.
  - **Distributed**: executes in parallel across multiple devices, such as several GPUs.

  MPAX's primary motivation is to integrate mathematical programming with deep learning pipelines. To achieve this, MPAX aligns its algorithms and implementations with the requirements of deep learning hardware, ensuring compatibility with GPUs and TPUs. By being differentiable, MPAX can integrate directly into the backpropagation process of neural network training. Its batchability and distributability further enable scalable deployment in large-scale applications.

  In this initial release, MPAX supports linear programming (LP), the foundational problem in mathematical programming. Future releases will expand support to include other problem classes of mathematical programming.



  You can install the latest released version of MPAX from PyPI via:
  ```
  pip install mpax
  ```
  or you can install the latest development version from GitHub:
  ```
  pip install git+https://github.com/MIT-Lu-Lab/mpax.git
  ```



  Currently, MPAX focuses on solving linear programming (LP) problems of the following form:
  ```math
  \begin{aligned}
  \min_{l \leq x \leq u}\ & c^\top x \\
  \text{s.t.}\ & A x = b \\
  & Gx \geq h
  \end{aligned}
  ```

  MPAX implements two state-of-the-art first-order methods for solving LP problems:
  * $\boldsymbol{\mathrm{ra}}$**PDHG**: [restarted average Primal-Dual Hybrid Gradient](https://arxiv.org/abs/2311.12180).
  * $\boldsymbol{\mathrm{r^2}}$**HPDHG**: [reflected restarted Halpern Primal-Dual Hybrid Gradient](https://arxiv.org/abs/2407.16144).



  ```python
  from mpax import create_lp, r2HPDHG

  lp = create_lp(c, A, b, G, h, l, u)
  solver = r2HPDHG(eps_abs=1e-4, eps_rel=1e-4, verbose=True)
  result = solver.optimize(lp)
  ```


  Batch solving allows you to solve multiple LP problems of the same shape simultaneously by using `jax.vmap`:
  ```python
  import jax.numpy as jnp
  from mpax import create_lp, r2HPDHG

  def single_optimize(c_vector):
      lp = create_lp(c_vector, A, b, G, h, l, u)
      solver = r2HPDHG(eps_abs=1e-4, eps_rel=1e-4, verbose=True)
      result = solver.optimize(lp)
      obj = jnp.dot(c_vector, result.primal_solution)
      return result.primal_solution, obj

  batch_size = 100
  batch_c = jnp.tile(c, (batch_size, 1))
  batch_optimize = jax.vmap(single_optimize)

  result = batch_optimize(batch_c)
  ```


  Distribute computations across devices using JAX’s sharding capabilities:

  ```python
  import jax
  from mpax import create_lp


  mesh = jax.make_mesh((2,), ('x',))
  sharding = jax.sharding.NamedSharding(mesh, P('x',))

  A_sharded = jax.device_put(A, sharding)
  lp_sharded = create_lp(c, A_sharded, b, G, h, l, u)

  solver = r2HPDHG(eps_abs=1e-4, eps_rel=1e-4, verbose=True)
  jit_optimize = jax.jit(solver.optimize)
  result = jit_optimize(lp_sharded)
  ```


  An Example of computing the forward and backward passes of the "Smart Predict-then-Optimize+" loss using MPAX and `jax.custom_jvp()`.
  ```python
  import jax
  import jax.numpy as jnp

  @jax.custom_vjp
  def pso_fun(pred_cost, true_cost, true_sol, true_obj):
      sol, obj = batch_optimize(2*pred_cost - true_cost)
      loss = -obj + 2 * jnp.sum(pred_cost * true_sol, axis=1) - true_obj
      loss = jnp.mean(loss)
      return loss, sol

  def spo_fwd(pred_cost, true_cost, true_sol, true_obj):
      loss, sol = pso_fun(pred_cost, true_cost, true_sol, true_obj)
      return loss, (sol, true_sol)

  def spo_bwd(res, g):
      sol, true_sol = res
      grad = 2 * (true_sol - sol)
      
      return grad * g, None, None, None

  pso_fun.defvjp(spo_fwd, spo_bwd)
  ```



  **General options**
  | Parameter                     | Type   | Default   | Description                                                             |
  |:-------------------------------:|:--------:|:-----------:|-------------------------------------------------------------------------|
  | `verbose`                    | bool   | `False`   | Enables detailed logging of the solver's progress.                     |
  | `debug`                      | bool   | `False`   | Activates additional debugging information.                            |
  | `display_frequency`          | int    | `10`      | Frequency (in every termination check) for displaying solver statistics.            |
  | `jit`                        | bool   | `True`    | Enables JIT (Just-In-Time) compilation for faster execution.            |
  | `unroll`                     | bool   | `False`   | Unrolls iteration loops.  |

  **Termination**
  | Parameter                        | Type   | Default     | Description                                                           |
  |:----------------------------------:|:--------:|:-------------:|-----------------------------------------------------------------------|
  | `eps_abs`                       | float  | `1e-4`      | Absolute tolerance for convergence.                                   |
  | `eps_rel`                       | float  | `1e-4`      | Relative tolerance for convergence.                                   |
  | `eps_primal_infeasible`         | float  | `1e-8`      | Tolerance for detecting primal infeasibility.                         |
  | `eps_dual_infeasible`           | float  | `1e-8`      | Tolerance for detecting dual infeasibility.                           |
  | `iteration_limit`               | int    | `max_int`   | Maximum number of iterations allowed (interpreted as unlimited by default). |

  **Precision**

  By default, MPAX uses single-precision (32-bit). To enable double-precision (64-bit), add the following at the start of your script:

  ```python
  jax.config.update("jax_enable_x64", True)
  ```

  **Determinism**

  Floating-point computations on GPUs in JAX may produce non-deterministic results. To ensure deterministic results, set:
  ```python
  os.environ["XLA_FLAGS"] = "--xla_gpu_deterministic_ops=true"
  ```
  **Important**: If you are using batch solving, do not enable `--xla_gpu_deterministic_ops=true`, as it can significantly degrade performance.


  If MPAX is useful or relevant to your research, please kindly recognize our contributions by citing our paper:
  ```bibtex
  @article{lu2024mpax,
    title={MPAX: Mathematical Programming in JAX},
    author={Lu, Haihao and Peng, Zedong and Yang, Jinwen},
    journal={arXiv preprint arXiv:2412.09734},
    year={2024}
  }
  ```


pkgId: 88223c75153791a56463b3a100d2aa8bc677cb1ba8622d7e81504f7aa7cc7f60
name: python-mpbuild-help
arch: noarch
version: 0.6
epoch: 0
release: 1
summary: Development documents and examples for mpbuild
url: https://pypi.org/project/mpbuild/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpbuild-0.6-1.src.rpm
location_href: Packages/python-mpbuild-help-0.6-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  ![](https://github.com/user-attachments/assets/2cf9fb34-aae4-4e24-a16c-76d387ca6dff)

  Build MicroPython firmware with ease!

  **mpbuild** builds MicroPython firmware in containers so you don't need to install any compiler toolchains or development tools. It knows which containers to use for each board so the appropriate build tools are used.

  </div>



  - [Usage](#usage)
    - [Advanced Usage](#advanced-usage)
    - [Use as a Module](#use-as-a-module)
  - [Installation](#installation)
    - [Prerequisites](#prerequisites)
  - [Examples](#examples)
  - [Related links](#related-links)



  **mpbuild** is intended to be executed in the root of a MicroPython repository. Help text (accessed with adding `--help`) is extensive and documents advanced options.

  > [!NOTE]
  > Note that there are some _special_ builds. `unix`, `webassembly` and `windows` can all be specified as `BOARD`s but their target isn't a microcontroller. See the [MicroPython documentation](https://github.com/micropython/micropython/) for details.

  > [!WARNING]
  > Currently **mpbuild** is tested on Linux (specifically Ubuntu 24.04 on WSL on Windows 11) but it's intended to work on any platform that supports Docker.

  Build a board, with optional variant:

  ```bash
  mpbuild build BOARD [VARIANT]
  ```

  Remove build artifacts:

  ```bash
  mpbuild clean BOARD [VARIANT]
  ```

  List the available boards, optionally filter by the port name.

  Displays the board names (as a clickable link), variants and number of boards per port:

  ```bash
  mpbuild list [PORT]
  ```



  Validate the state of all images referenced in board definitions:

  ```bash
  mpbuild check_images
  ```



  > [!CAUTION]
  > This is _very much_ a work-in-progress and the API is subject to change.

  **mpbuild** can also be used from Python as a module. This allows it to easily be integrated into other tools.

  Example:

  ```python
  import mpbuild

  mpbuild.build("RPI_PICO")
  mpbuild.list()
  ```



  ```bash
  uv tool install mpbuild
  ```

  Or use pipx, pip etc.

  After installation, you may want to also install command-line tab completion for your shell (bash, zsh, fish and PowerShell are supported). Tab completion includes the various mpbuild commands as well as the board names and variants:

  ```bash
  mpbuild --install-completion
  ```



  A clone of MicroPython (or a fork):

  ```bash
  git clone git@github.com:micropython/micropython.git
  ```

  [Docker](https://www.docker.com/) is currently necessary for managing containers and must be installed and available on your system path.



  ```bash
  $ mpbuild build RPI_PICO

  ```

  ```bash
  $ mpbuild list rp2
  🐍 MicroPython Boards
  └── rp2   19
      ├── ADAFRUIT_FEATHER_RP2040
      ├── ADAFRUIT_ITSYBITSY_RP2040
      ├── ADAFRUIT_QTPY_RP2040
      ├── ARDUINO_NANO_RP2040_CONNECT
      ├── GARATRONIC_PYBSTICK26_RP2040
      ├── NULLBITS_BIT_C_PRO
      ├── PIMORONI_PICOLIPO  FLASH_16M
      ├── PIMORONI_TINY2040  FLASH_8M
      ├── POLOLU_3PI_2040_ROBOT
      ├── POLOLU_ZUMO_2040_ROBOT
      ├── RPI_PICO
      ├── RPI_PICO2  RISCV
      ├── RPI_PICO_W
      ├── SIL_RP2040_SHIM
      ├── SPARKFUN_PROMICRO
      ├── SPARKFUN_THINGPLUS
      ├── W5100S_EVB_PICO
      ├── W5500_EVB_PICO
      └── WEACTSTUDIO  FLASH_2M, FLASH_4M, FLASH_8M
  ```


pkgId: 59624885abd5b41be1d6b2eba46258fa93abf63a2d10c32d15d94b38105a9fcd
name: python-mpc-obscodes-help
arch: noarch
version: 2024.12.19
epoch: 0
release: 1
summary: Development documents and examples for mpc-obscodes
url: https://pypi.org/project/mpc-obscodes/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpc-obscodes-2024.12.19-1.src.rpm
location_href: Packages/python-mpc-obscodes-help-2024.12.19-1.noarch.rpm
checksum_type: sha256
description:
  [![Python 3.7+](https://img.shields.io/badge/Python-3.7%2B-blue)](https://img.shields.io/badge/Python-3.7%2B-blue)
  [![PyPI version](https://img.shields.io/pypi/v/mpc-obscodes)](https://img.shields.io/pypi/v/mpc-obscodes)
  [![PyPi downloads](https://img.shields.io/pypi/dm/mpc-obscodes)](https://img.shields.io/pypi/dm/mpc-obscodes)
  [![Build and Test](https://github.com/B612-Asteroid-Institute/mpc_obscodes/actions/workflows/build_test.yml/badge.svg)](https://github.com/B612-Asteroid-Institute/mpc_obscodes/actions/workflows/build_test.yml)
  [![Build, Test, & Publish](https://github.com/B612-Asteroid-Institute/mpc_obscodes/actions/workflows/build_test_publish.yml/badge.svg)](https://github.com/B612-Asteroid-Institute/mpc_obscodes/actions/workflows/build_test_publish.yml)
  [![Compare Upstream](https://github.com/B612-Asteroid-Institute/mpc_obscodes/actions/workflows/compare_upstream.yml/badge.svg)](https://github.com/B612-Asteroid-Institute/mpc_obscodes/actions/workflows/compare_upstream.yml)

  This package ships the Minor Planet Center's [file](https://minorplanetcenter.net/Extended_Files/obscodes_extended.json.gz) of observatory codes and their geodetic coordinates.

  **This is not an official MPC package**. It is an automatically generated mirror of the file so that it is
  installable via `pip`.

  Every night at around 2:15 AM UTC, the MPC observatory code file is downloaded and compared (via md5 checksum) to the current version of this package. If the checksums are different, a new package will be published.



  The latest version of the file can be install via pip:
  `pip install mpc-obscodes`


  ```python
  import pandas as pd
  from mpc_obscodes import mpc_obscodes

  obscodes = pd.read_json(mpc_obscodes, orient="index")
  ```



  This research has made use of data and/or services provided by the International Astronomical Union's Minor Planet Center.

  See the Minor Planet Center's [website](https://cgi.minorplanetcenter.net/) for more details.


pkgId: 11098541d443a5f10e3950214b8aa9f970ca9066b00b393e5d5303c3aa652415
name: python-mpflash-help
arch: noarch
version: 1.24.4
epoch: 0
release: 1
summary: Development documents and examples for mpflash
url: https://github.com/Josverl/micropython-stubber/blob/main/src/mpflash/README.md
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpflash-1.24.4-1.src.rpm
location_href: Packages/python-mpflash-help-1.24.4-1.noarch.rpm
checksum_type: sha256
description:
    [![pypi version](https://badgen.net/pypi/v/mpflash)](https://pypi.org/project/mpflash/)
    [![python versions](https://badgen.net/pypi/python/mpflash)](https://badgen.net/pypi/python/mpflash)
  [![Downloads](https://static.pepy.tech/badge/mpflash)](https://pepy.tech/project/mpflash)


  `mpflash` is a command-line tool for working with MicroPython firmware. It provides features to help you flash and update Micropython on one or more .

  This tool was initially created to be used in a CI/CD pipeline to automate the process of downloading and flashing MicroPython firmware to multiple boards, but it has been extend with a TUI to be used for manual downloadig, flashing and development.

  `mpflash` has been tested on:
   - OS: Windows x64, Linux X64, and macOS.
   - Micropython (hardware) ports:
      - `rp2`, using `.uf2`, using filecopy
      - `samd`, using ` .uf2`, using filecopy
      - `esp32`, using `.bin`, using esptool,
      - `esp8266`, using `.bin`, using esptool
      - `stm32`, using ` .dfu`, using pydfu

  Not yet implemented: `nrf`, `cc3200`, `mimxrt`, `renesas`


   1. List the connected boards including their firmware details, in a tabular or json format
   2. Download MicroPython firmware for versions, and matching a specified board or matches your current attached board.
   3. Flash one or all connected MicroPython boards with a specific firmware or version.


  To install mpflash, you can use: `pipx install mpflash` or `pip install mpflash`


  You can use mpflash to perform various operations on your MicroPython boards. Here is an example of basic usage:

  | Command | Description |
  |---------|-------------|
  | `mpflash list` | List the connected board(s) including their firmware details |
  | `mpflash download` | Download the MicroPython firmware(s) for the connected board(s) |
  | `mpflash flash` | Flash the latest stable firmware to the connected board(s) |



  You can use the `--serial` option to select a specific serial port to flash, or the `--ignore` option to ignore a specific serial port.
  both options can be specified multiple times
  Both can be globs (e.g. COM*) or exact port names (e.g. COM1)
  in addition there is a --bluetooth option to simplify ignoring bluetooth ports

  ```
  --serial,--serial-port      -s      SERIALPORT  Serial port(s) (or globs) to list. [default: *]                                                                                                                                                                           > > --ignore                    -i      SERIALPORT  Serial port(s) (or globs) to ignore. Defaults to MPFLASH_IGNORE.                                                                                                                                                          │
  --bluetooth/--no-bluetooth  -b/-nb              Include bluetooth ports in the list [default: no-bluetooth]
  ```


  The `mpflash list` command will list all connected boards, but sometimes you have multiple boards of the same type connected.
  To help you identify the boards, you can add a board_info.toml file to the top/default folder for the board.
  This file can contain a description of the board, which will be shown in the list and json output.
  ```toml
  description = "Blue Norwegian actuator"
  ```

  If you want the board to be ignored by mpflash, you can add the following to the board_info.toml file:
  ```toml
  [mpflash]
  ignore = true
  ```



  In order to flash the firmware to the board, you need to have the correct permissions to access the USB devices.
  On Windows this will not be an issue, but on Linux you can use  udev rules to give non-root users access to the USB devices.
  [See the stm32_permissions documentation](./stm32_udev_rules.md) for more information.



  You can list the connected boards using the following command:
  ```bash
  $> mpflash list
                                                 Connected boards
  ┏━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━┓
  ┃ Serial  ┃Family       ┃Port  ┃Board                                      ┃CPU     ┃Version          ┃build ┃
  ┡━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━┩
  │ COM21   │micropython  │rp2   │RPI_PICO                                   │RP2040  │v1.23.0-preview  │  236 │
  │         │             │      │Raspberry Pi Pico with RP2040              │        │                 │      │
  │ COM23   │micropython  │rp2   │RPI_PICO_W                                 │RP2040  │v1.23.0-preview  │  176 │
  │         │             │      │Raspberry Pi Pico W with RP2040            │        │                 │      │
  │ COM9    │micropython  │rp2   │ARDUINO_NANO_RP2040_CONNECT                │RP2040  │v1.23.0-preview  │  341 │
  │         │             │      │Arduino Nano RP2040 Connect with RP2040    │        │                 │      │
  └─────────┴─────────────┴──────┴───────────────────────────────────────────┴────────┴─────────────────┴──────┘
  ```


  To download the MicroPython firmware for some boards, use the following command:
   - `mpflash download` download the latest stable firmware for all connected boards
   - `mpflash download --version preview` download the current preview for all connected boards
   - `mpflash download --board ESP8266_GENERIC --board SEEED_WIO_TERMINAL` download these specific boards
   - `mpflash download --version ? --board ?` prompt to select a specific version and board to download

  These will try to download the prebuilt MicroPython firmware for the boards from https://micropython.org/download/ and save it in your downloads folder in the  `firmware` directory.
  The stable version (default) is determined based on the most recent published release,
  other options are `--version stable`, `--version preview` and `--version x.y.z` to download the latest stable, preview or version x.y.z respectively.

  By default the firmware will be downloaded to your OS's preferred `Downloads/firmware` folder, but you can speciy a different directory using the `--dir` option.

  The directory structure will be something like this:

  ``` text
  Downloads/firmware
  |   firmware.jsonl
  +---esp8266
  |       ESP8266_GENERIC-FLASH_1M-v1.22.2.bin
  |       ESP8266_GENERIC-FLASH_512K-v1.22.2.bin
  |       ESP8266_GENERIC-OTA-v1.22.2.bin
  |       ESP8266_GENERIC-v1.22.2.bin
  \---samd
          SEEED_WIO_TERMINAL-v1.22.2.uf2
  ```


  After you have downloaded a firmware you can  flash the firmware to a board using the following command: `mpflash flash`
  This will (try to) autodetect the connected boards, and determine the correct firmware to flash to each board.

  - `mpflash flash` will flash the latest stable firmware to all connected boards.
  If you have a board withouth a running micropython version, you will need to specify the board and the serial port to flash.
  - `mpflash flash --serial ? --board ?` will prompt to select a specific serial port and board to flash. (the firmware must be dowloaded earlier)

  In order to flash the firmware some boards need to be put in bootloader mode, this is done automatically by mpflash where possible and supported by the boards hardware and current bootloader.
  The supported `--bootloader` options are:

  - `touch1200` bootloader is activated by connecting to the board at 1200 baud
  - `mpy`  using  micropython to enter the bootloader
  - `manual` manual intervention is needed to enter the bootloader
  - `none`   mpflash assumes the board is ready to flash

  For ESP32 and ESP8266 boards the `esptool` is used to flash the firmware, and this includes activating the bootloader.


  ```bash
  > mpflash flash
  22:15:55 | ℹ️  - Using latest stable version: v1.22.2
                                         Connected boards
  ┏━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━┓
  ┃ Serial ┃ Family      ┃ Port    ┃ Board              ┃ CPU         ┃ Version        ┃ build ┃
  ┡━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━┩
  │ COM11  │ micropython │ rp2     │ RPI_PICO_W         │ RP2040      │ 1.20.0         │       │
  │ COM12  │ micropython │ esp8266 │ ESP8266_GENERIC    │ ESP8266     │ 1.22.2         │       │
  │ COM18  │ micropython │ rp2     │ RPI_PICO_W         │ RP2040      │ 1.23.0-preview │ 155   │
  │ COM3   │ micropython │ samd    │ SEEED_WIO_TERMINAL │ SAMD51P19A  │ 1.23.0-preview │ 155   │
  │ COM5   │ micropython │ stm32   │ PYBV11             │ STM32F405RG │ 1.23.0-preview │ 166   │
  │ COM8   │ micropython │ esp32   │ ESP32_GENERIC_S3   │ ESP32S3     │ 1.23.0-preview │ 155   │
  └────────┴─────────────┴─────────┴────────────────────┴─────────────┴────────────────┴───────┘
  22:15:58 | ℹ️  - Found v1.22.2 firmware rp2\RPI_PICO_W-v1.22.2.uf2 for RPI_PICO_W on COM11.
  22:15:58 | ℹ️  - Found v1.22.2 firmware esp8266\ESP8266_GENERIC-v1.22.2.bin for ESP8266_GENERIC on COM12.
  22:15:58 | ℹ️  - Found v1.22.2 firmware rp2\RPI_PICO_W-v1.22.2.uf2 for RPI_PICO_W on COM18.
  22:15:58 | ℹ️  - Found v1.22.2 firmware samd\SEEED_WIO_TERMINAL-v1.22.2.uf2 for SEEED_WIO_TERMINAL on COM3.
  22:15:58 | ⚠️  - Trying to find a firmware for the board PYBV11
  22:15:58 | ❌  - No v1.22.2 firmware found for PYBV11 on COM5.
  22:15:58 | ⚠️  - Trying to find a firmware for the board ESP32-GENERIC-S3
  22:15:58 | ❌  - No v1.22.2 firmware found for ESP32_GENERIC_S3 on COM8.
  22:15:58 | ℹ️  - Updating RPI_PICO_W on COM11 to 1.22.2
  22:15:58 | ℹ️  - Erasing not yet implemented for UF2 flashing.
  22:15:58 | ℹ️  - Entering UF2 bootloader on RPI_PICO_W on COM11
  22:15:58 | ℹ️  - Waiting for mcu to mount as a drive : 10 seconds left
  22:15:59 | ℹ️  - Waiting for mcu to mount as a drive : 9 seconds left
  22:16:00 | ℹ️  - Board is in bootloader mode
  22:16:00 | ℹ️  - Copying firmware\rp2\RPI_PICO_W-v1.22.2.uf2 to F:
  22:16:13 | ✅  - Done copying, resetting the board and wait for it to restart
  22:16:23 | ℹ️  - Updating ESP8266_GENERIC on COM12 to 1.22.2
  22:16:23 | ℹ️  - Flashing firmware\esp8266\ESP8266_GENERIC-v1.22.2.bin on ESP8266_GENERIC on COM12
  22:16:23 | ℹ️  - Running esptool --chip ESP8266 --port COM12 erase_flash
  esptool.py v4.7.0
  Serial port COM12
  Connecting....
  ...
  Chip erase completed successfully in 6.5s
  Hard resetting via RTS pin...
  22:16:31 | ℹ️  - Running esptool --chip ESP8266 --port COM12 -b 460800 write_flash --flash_size=detect 0x0 firmware\esp8266\ESP8266_GENERIC-v1.22.2.bin
  esptool.py v4.7.0
  Serial port COM12
  Connecting....
  ...
  Leaving...
  Hard resetting via RTS pin...
  22:16:43 | ℹ️  - Done flashing, resetting the board and wait for it to restart
  22:16:49 | ✅  - Flashed 1.22.2 to ESP8266_GENERIC on COM12 done
  22:16:49 | ℹ️  - Updating RPI_PICO_W on COM18 to 1.22.2
  22:16:49 | ℹ️  - Erasing not yet implemented for UF2 flashing.
  22:16:49 | ℹ️  - Entering UF2 bootloader on RPI_PICO_W on COM18
  22:16:49 | ℹ️  - Waiting for mcu to mount as a drive : 10 seconds left
  22:16:50 | ℹ️  - Waiting for mcu to mount as a drive : 9 seconds left
  22:16:51 | ℹ️  - Board is in bootloader mode
  22:16:51 | ℹ️  - Copying firmware\rp2\RPI_PICO_W-v1.22.2.uf2 to F:[/bold]
  22:17:02 | ✅  - Done copying, resetting the board and wait for it to restart
  22:17:12 | ℹ️  - Updating SEEED_WIO_TERMINAL on COM3 to 1.22.2
  22:17:12 | ℹ️  - Erasing not yet implemented for UF2 flashing.
  22:17:12 | ℹ️  - Entering UF2 bootloader on SEEED_WIO_TERMINAL on COM3
  22:17:12 | ℹ️  - Waiting for mcu to mount as a drive : 10 seconds left
  22:17:13 | ℹ️  - Waiting for mcu to mount as a drive : 9 seconds left
  22:17:14 | ℹ️  - Board is in bootloader mode
  22:17:14 | ℹ️  - Copying firmware\samd\SEEED_WIO_TERMINAL-v1.22.2.uf2 to F:[/bold]
  22:17:17 | ✅  - Done copying, resetting the board and wait for it to restart
  22:17:27 | ℹ️  - Flashed 4 boards
                                 Connected boards after flashing
  ┏━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━┓
  ┃ Serial ┃ Family      ┃ Port    ┃ Board              ┃ CPU         ┃ Version        ┃ build ┃
  ┡━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━┩
  │ COM11  │ micropython │ rp2     │ RPI_PICO_W         │ RP2040      │ 1.22.2         │       │
  │ COM12  │ micropython │ esp8266 │ ESP8266_GENERIC    │ ESP8266     │ 1.22.2         │       │
  │ COM18  │ micropython │ rp2     │ RPI_PICO_W         │ RP2040      │ 1.22.2         │       │
  │ COM3   │ micropython │ samd    │ SEEED_WIO_TERMINAL │ SAMD51P19A  │ 1.22.2         │       │
  │ COM5   │ micropython │ stm32   │ PYBV11             │ STM32F405RG │ 1.23.0-preview │ 166   │
  │ COM8   │ micropython │ esp32   │ ESP32_GENERIC_S3   │ ESP32S3     │ 1.23.0-preview │ 155   │
  └────────┴─────────────┴─────────┴────────────────────┴─────────────┴────────────────┴───────┘
  ```
  Note that if no matching firmware can be found for a board, it will be skipped.
  (For example, the PYBV11 and ESP32_GENERIC_S3 boards in the example above.)


  mpflash is currently co-located in the [micropython-stubber](https://github.com/Josverl/micropython-stubber) repository.
  Please report any issues or bugs in the [issue tracker](https://github.com/Josverl/micropython-stubber/issues) using the MPflash feedback template.


  mpflash is licensed under the MIT license. See the LICENSE file for more details.


pkgId: 832f20133c354713945a862912aee0f5d4dadeba3a401de482d31614695b01d6
name: python-mplchart
arch: noarch
version: 0.0.15
epoch: 0
release: 1
summary: Classic Stock Charts in Python
url: https://pypi.org/project/mplchart/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mplchart-0.0.15-1.src.rpm
location_href: Packages/python-mplchart-0.0.15-1.noarch.rpm
checksum_type: sha256
description:
  Create classic technical analysis stock charts in Python with minimal code.
  The library is built around [matplotlib](https://github.com/matplotlib/matplotlib)
  and [pandas](https://github.com/pandas-dev/pandas).
  Charts can be defined using a declarative interface,
  based on a set of drawing primitives like `Candleststicks`, `Volume`
  and technical indicators like `SMA`, `EMA`, `RSI`, `ROC`, `MACD`, etc ...


  > **Warning**
  > This project is experimental and the interface can change.
  > For a similar project with a mature api you may want to look into
  > [mplfinance](https://pypi.org/project/mplfinance/).


  ![Showcase Chart](https://github.com/furechan/mplchart/raw/main/output/showcase.svg "Showcase")




  ```python


  import yfinance as yf

  from mplchart.chart import Chart
  from mplchart.primitives import Candlesticks, Volume
  from mplchart.indicators import SMA, EMA, ROC, RSI, MACD

  ticker = 'AAPL'
  prices = yf.Ticker(ticker).history('5y')

  max_bars = 250

  indicators = [
      Candlesticks(),
      Volume(),
      SMA(50),
      SMA(200),
      RSI(),
      MACD(),
  ]

  chart = Chart(title=ticker, max_bars=max_bars)
  chart.plot(prices, indicators)
  chart.show()
  ```




  Price data is expected to be presented as a pandas DataFrame
  with columns `open`, `high`, `low`, `close` `volume`
  and a datetime index named `date` or `datetime`.
  Please note, the library will automatically convert column
  and index names to lower case for its internal use.




  The library contains drawing primitives that can be used like an indicator in the plot api.
  Primitives are classes and must be instantiated as objects before being used with the plot api.

  ```python


  from mplchart.chart import Chart
  from mplchart.primitives import Candlesticks

  indicators = [Candlesticks()]
  chart = Chart(title=title, max_bars=max_bars)
  chart.plot(prices, indicators)
  ```

  The main drawing primitives are :
  - `Candlesticks` for candlestick plots
  - `OHLC` for open, high, low, close bar plots
  - `Price` for price line plots
  - `Volume` for volume bar plots
  - `Peaks` to mark peaks and valleys
  - `SameAxes` to use same axes as last plot
  - `NewAxes` to use new axes above or below
  - `LinePlot` draw an indicator as line plot
  - `AreaPlot` draw an indicator as area plot
  - `BarPlot` draw an indicator as bar plot






  The libary includes some standard technical analysis indicators implemented in pandas/numpy.
  Indicators are classes and must be instantiated as objects before being used with the plot api.

  Some of the indicators included are:

  - `SMA` Simple Moving Average
  - `EMA` Exponential Moving Average
  - `WMA` Weighted Moving Average
  - `HMA` Hull Moving Average
  - `ROC` Rate of Change
  - `RSI` Relative Strength Index
  - `ATR` Average True Range
  - `ATRP` Average True Range Percent
  - `ADX` Average Directional Index
  - `DMI` Directional Movement Index
  - `MACD` Moving Average Convergence Divergence
  - `PPO` Price Percentage Oscillator
  - `SLOPE` Slope (time linear regression)
  - `STOCH` Stochastic Oscillator
  - `BBANDS` Bollinger Bands





  If you have [ta-lib](https://github.com/mrjbq7/ta-lib) installed you can use the library abstract functions as indicators.
  The indicators are created by calling `Function` with the name of the indicator and its parameters.

  ```python


  from mplchart.primitives import Candlesticks
  from talib.abstract import Function

  indicators = [
      Candlesticks(),
      Function('SMA', 50),
      Function('SMA', 200),
      Function('RSI'),
      Function('MACD'),
  ]
  ```




  Most indicators are drawn as line plots with default colors and settings. You can override the rendering of an indicator by piping it with the `|` operator into a primitive like `LinePlot`, `AreaPlot` or `BarPlot` as in the example below. If the indicator returns a dataframe instead of a series you need to specify an `item` (column name) in the primitive.


  ```python


  from mplchart.indicators import SMA, EMA, ROC
  from mplchart.primitives import Candlesticks, LinePlot

  indicators = [
      Candlesticks(),
      SMA(20) | LinePlot(style="dashed", color="red", alpha=0.5, width=3)
  ]
  ```




  Indicators usually plot in a new axes below, except for a few indicators that plot by default in the main axes. You can change the target axes for any indicator by piping it into an axes primitive as in the example below.

  ```python


  from mplchart.indicators import SMA, EMA, ROC
  from mplchart.primitives import Candlesticks, SameAxes

  indicators = [
      Candlesticks(),
      ROC(20),
      ROC(50) | SameAxes(),
  ]
  ```




  Any callable that accepts a prices dataframe and returns a series or dataframe can be used as an indicator.
  You can also implement a custom indicator as a subclass of `Indicator`.

  ```python


  from mplchart.model import Indicator
  from mplchart.library import get_series, calc_ema

  class DEMA(Indicator):
      """Double Exponential Moving Average"""

      same_scale = True
      
      
      

      def __init__(self, period: int = 20):
          self.period = period

      def __call__(self, prices):
          series = get_series(prices)
          ema1 = calc_ema(series, self.period)
          ema2 = calc_ema(ema1, self.period)
          return 2 * ema1 - ema2
  ```





  You can find example notebooks and scripts in the `examples` folder.



  You can install the current version of this package with pip

  ```console
  python -mpip install git+https://github.com/furechan/mplchart.git
  ```



  - python >= 3.9
  - matplotlib
  - pandas
  - numpy



  - [stockcharts.com](https://stockcharts.com/) Classic stock charts and technical analysis reference
  - [mplfinance](https://pypi.org/project/mplfinance/) Matplotlib utilities for the visualization, and visual analysis, of financial data
  - [matplotlib](https://github.com/matplotlib/matplotlib) Matplotlib: plotting with Python
  - [pandas](https://github.com/pandas-dev/pandas) Flexible and powerful data analysis / manipulation library for Python, providing labeled data structures similar to R data.frame objects, statistical functions, and much more
  - [yfinance](https://github.com/ranaroussi/yfinance) Download market data from Yahoo! Finance's API
  - [ta-lib](https://github.com/mrjbq7/ta-lib) Python wrapper for TA-Lib


pkgId: d7d938343b4a319d4eed486204f1b18989ed64a1e3fe02af78ae212636a80f98
name: python-mpservice-help
arch: noarch
version: 0.16.4
epoch: 0
release: 1
summary: Development documents and examples for mpservice
url: https://pypi.org/project/mpservice/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpservice-0.16.4-1.src.rpm
location_href: Packages/python-mpservice-help-0.16.4-1.noarch.rpm
checksum_type: sha256
description:
  The package ``mpservice`` provides a few groups of facilities. The first group helps ochestrating an operation
  with multiple stages/components in threads and processes, such as a machine learning model;
  the second group concerns stream processing, optionally involving threads or processes for concurrency;
  the third group provides customization and enhancements to the standard packages ``multiprocessing`` and ``threading``.
  The central theme of ``mpservice`` is concurrency by threads or processes.
  Read the `documentation <https://mpservice.readthedocs.io/en/latest/>`_.
  To install, do
      python3 -m pip install mpservice


pkgId: adb78ff8ca33c97808f12b280e298eb27cf35a7bb4821c5048b4227f80752589
name: python-mpx-genai-sdk-help
arch: noarch
version: 0.1.2b1
epoch: 0
release: 1
summary: Development documents and examples for mpx-genai-sdk
url: https://github.com/masterpiecevr/mpx-sdk-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpx-genai-sdk-0.1.2b1-1.src.rpm
location_href: Packages/python-mpx-genai-sdk-help-0.1.2b1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/mpx_genai_sdk.svg)](https://pypi.org/project/mpx_genai_sdk/)

  The Masterpiecex Python library provides convenient access to the Masterpiecex REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [developers.masterpiecex.com](https://developers.masterpiecex.com/docs). The full API of this library can be found in [api.md](https://github.com/masterpiecevr/mpx-sdk-python/tree/main/api.md).



  ```sh

  pip install --pre mpx_genai_sdk
  ```



  The full API of this library can be found in [api.md](https://github.com/masterpiecevr/mpx-sdk-python/tree/main/api.md).

  ```python
  import os
  from mpx_genai_sdk import Masterpiecex

  client = Masterpiecex(
      bearer_token=os.environ.get("MPX_SDK_BEARER_TOKEN"),  # This is the default and can be omitted
  )

  create_response_object = client.assets.create(
      description="my description of the asset",
      name="asset1.glb",
      type="model/gltf-binary",
  )
  print(create_response_object.asset_url)
  ```

  While you can provide a `bearer_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `MPX_SDK_BEARER_TOKEN="My Bearer Token"` to your `.env` file
  so that your Bearer Token is not stored in source control.



  Simply import `AsyncMasterpiecex` instead of `Masterpiecex` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from mpx_genai_sdk import AsyncMasterpiecex

  client = AsyncMasterpiecex(
      bearer_token=os.environ.get("MPX_SDK_BEARER_TOKEN"),  # This is the default and can be omitted
  )


  async def main() -> None:
      create_response_object = await client.assets.create(
          description="my description of the asset",
          name="asset1.glb",
          type="model/gltf-binary",
      )
      print(create_response_object.asset_url)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `mpx_genai_sdk.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `mpx_genai_sdk.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `mpx_genai_sdk.APIError`.

  ```python
  import mpx_genai_sdk
  from mpx_genai_sdk import Masterpiecex

  client = Masterpiecex()

  try:
      client.assets.create(
          description="my description of the asset",
          name="asset1.glb",
          type="model/gltf-binary",
      )
  except mpx_genai_sdk.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except mpx_genai_sdk.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except mpx_genai_sdk.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from mpx_genai_sdk import Masterpiecex


  client = Masterpiecex(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).assets.create(
      description="my description of the asset",
      name="asset1.glb",
      type="model/gltf-binary",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from mpx_genai_sdk import Masterpiecex


  client = Masterpiecex(
      
      timeout=20.0,
  )


  client = Masterpiecex(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).assets.create(
      description="my description of the asset",
      name="asset1.glb",
      type="model/gltf-binary",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/masterpiecevr/mpx-sdk-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `MASTERPIECEX_LOG` to `info`.

  ```shell
  $ export MASTERPIECEX_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from mpx_genai_sdk import Masterpiecex

  client = Masterpiecex()
  response = client.assets.with_raw_response.create(
      description="my description of the asset",
      name="asset1.glb",
      type="model/gltf-binary",
  )
  print(response.headers.get('X-My-Header'))

  asset = response.parse()  # get the object that `assets.create()` would have returned
  print(asset.asset_url)
  ```

  These methods return an [`APIResponse`](https://github.com/masterpiecevr/mpx-sdk-python/tree/main/src/mpx_genai_sdk/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/masterpiecevr/mpx-sdk-python/tree/main/src/mpx_genai_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.assets.with_streaming_response.create(
      description="my description of the asset",
      name="asset1.glb",
      type="model/gltf-binary",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from mpx_genai_sdk import Masterpiecex, DefaultHttpxClient

  client = Masterpiecex(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/masterpiecevr/mpx-sdk-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import mpx_genai_sdk
  print(mpx_genai_sdk.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/masterpiecevr/mpx-sdk-python/tree/main/./CONTRIBUTING.md).


pkgId: da6f6cf4cda893e3cdd5ede2914d40c6c69d6ce03dc25df99d9cbe20441bd9c6
name: python-mpxj-help
arch: noarch
version: 13.8.0
epoch: 0
release: 1
summary: Development documents and examples for mpxj
url: https://github.com/joniles/mpxj
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mpxj-13.8.0-1.src.rpm
location_href: Packages/python-mpxj-help-13.8.0-1.noarch.rpm
checksum_type: sha256
description:
  [MPXJ](http://mpxj.org) is a Java library which allows a variety of project
  file formats and databases to be read and written. This Python package uses
  the [JPype](https://pypi.org/project/JPype1/) Java bridge to allow direct
  access from Python to the MPXJ library. You can find details of the Java
  classes and methods in the [Javadocs](http://www.mpxj.org/apidocs/index.html), and more general documentation
  on the [MPXJ website](https://www.mpxj.org/).

  After installing this package you can either work with some of the simple built-in
  utilities provided by MPXJ for tasks like file format conversion:

  ```python
  import jpype
  import mpxj

  jpype.startJVM()
  from net.sf.mpxj.sample import MpxjConvert
  MpxjConvert().process('example.mpp', 'example.mpx')
  jpype.shutdownJVM()
  ```

  or you can interact directly with the object model exposed by MPXJ to extract data:

  ```python
  import jpype
  import mpxj

  jpype.startJVM()
  from net.sf.mpxj.reader import UniversalProjectReader
  project = UniversalProjectReader().read('example.mpp')

  print("Tasks")
  for task in project.getTasks():
  	print(task.getID().toString() + "\t" + task.getName())

  jpype.shutdownJVM()
  ```

  or finally you can generate your own schedule:

  ```python
  import jpype
  import mpxj

  jpype.startJVM()

  from java.lang import Double
  from java.time import LocalDate, LocalDateTime
  from net.sf.mpxj import ProjectFile, TaskField, Duration, TimeUnit, RelationType, Availability, Relation
  from net.sf.mpxj.common import LocalDateTimeHelper
  from net.sf.mpxj.writer import UniversalProjectWriter, FileFormat



  file_name = "test.xml"
  file_format = FileFormat.MSPDI


  file = ProjectFile()


  calendar = file.addDefaultBaseCalendar()


  calendar.addCalendarException(LocalDate.of(2006, 3, 13), LocalDate.of(2006, 3, 13))






  properties = file.getProjectProperties()
  properties.setStartDate(LocalDateTime.of(2003, 1, 1, 8, 0))


  properties.setProjectTitle("Created by MPXJ")
  properties.setAuthor("Jon Iles")


  customFields = file.getCustomFields()
  field = customFields.getOrCreate(TaskField.TEXT1)
  field.setAlias("My Custom Field")


  resource1 = file.addResource()
  resource1.setName("Resource1")

  resource2 = file.addResource()
  resource2.setName("Resource2")

  resource2.getAvailability().add(Availability(LocalDateTimeHelper.START_DATE_NA, LocalDateTimeHelper.END_DATE_NA, Double.valueOf(50.0)));



  task1 = file.addTask()
  task1.setName("Summary Task")


  task2 = task1.addTask()
  task2.setName("First Sub Task")
  task2.setDuration(Duration.getInstance(10.5, TimeUnit.DAYS))
  task2.setStart(LocalDateTime.of(2003, 1, 1, 8, 0))
  task2.setText(1, "My Custom Value 1")







  task2.setPercentageComplete(Double.valueOf(50.0))
  task2.setActualStart(LocalDateTime.of(2003, 1, 1, 8, 0))


  task3 = task1.addTask()
  task3.setName("Second Sub Task")
  task3.setStart(LocalDateTime.of(2003, 1, 11, 8, 0))
  task3.setDuration(Duration.getInstance(10, TimeUnit.DAYS))
  task3.setText(1, "My Custom Value 2")



  task3.addPredecessor(Relation.Builder().targetTask(task2))


  milestone1 = task1.addTask()
  milestone1.setName("Milestone")
  milestone1.setStart(LocalDateTime.of(2003, 1, 21, 8, 0))
  milestone1.setDuration(Duration.getInstance(0, TimeUnit.DAYS))
  milestone1.addPredecessor(Relation.Builder().targetTask(task3))




  task4 = file.addTask()
  task4.setName("Next Task")
  task4.setDuration(Duration.getInstance(8, TimeUnit.DAYS))
  task4.setStart(LocalDateTime.of(2003, 1, 1, 8, 0))
  task4.setPercentageComplete(Double.valueOf(70.0))
  task4.setActualStart(LocalDateTime.of(2003, 1, 1, 8, 0))


  assignment1 = task2.addResourceAssignment(resource1)
  assignment2 = task3.addResourceAssignment(resource2)





  assignment1.setWork(Duration.getInstance(80, TimeUnit.HOURS))
  assignment1.setActualWork(Duration.getInstance(40, TimeUnit.HOURS))






  assignment1.setRemainingWork(Duration.getInstance(40, TimeUnit.HOURS))
  assignment2.setRemainingWork(Duration.getInstance(80, TimeUnit.HOURS))
  assignment1.setStart(LocalDateTime.of(2003, 1, 1, 8, 0))
  assignment2.setStart(LocalDateTime.of(2003, 1, 11, 8, 0))


  task5 = file.addTask()
  task5.setName("Last Task")
  task5.setDuration(Duration.getInstance(3, TimeUnit.DAYS))
  task5.setStart(LocalDateTime.of(2003, 1, 1, 8, 0))
  task5.setPercentageComplete(Double.valueOf(100.0))
  task5.setActualStart(LocalDateTime.of(2003, 1, 1, 8, 0))


  task6 = file.addTask()
  task6.setName("Last Milestone")
  task6.setDuration(Duration.getInstance(0, TimeUnit.DAYS))
  task6.setStart(LocalDateTime.of(2003, 1, 1, 8, 0))
  task6.setPercentageComplete(Double.valueOf(100.0))
  task6.setActualStart(LocalDateTime.of(2003, 1, 1, 8, 0))


  writer = UniversalProjectWriter(file_format).write(file, file_name)

  jpype.shutdownJVM()
  ```


pkgId: 23f9ae3e252b9e948b91c6d10dfc490337e60c4c1669b74dc8f2eec3fc3776f7
name: python-mqtt-backend-serrawatch-help
arch: noarch
version: 0.2.13
epoch: 0
release: 1
summary: Development documents and examples for mqtt-backend-serrawatch
url: https://github.com/IOTSerraWatch/Client_OnUbuntu
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mqtt-backend-serrawatch-0.2.13-1.src.rpm
location_href: Packages/python-mqtt-backend-serrawatch-help-0.2.13-1.noarch.rpm
checksum_type: sha256
description:
  This project was created as part of the Internet of Things (IoT) course in the Master's program in Computer Architecture at the Haute École de la Province de Liège (HEPL). Its objective is to demonstrate the design, development, and integration of IoT solutions to meet real-world needs in terms of connectivity and automation. This project puts into practice technical skills such as programming embedded devices, wireless communication, and designing intelligent and interactive systems.

  The focus is on using hardware like the Raspberry Pi and various sensors, while integrating communication protocols such as MQTT to illustrate key IoT principles and promote a hands-on learning approach.

  If anyone finds any security vulnerabilities, I would be happy to discuss them.


pkgId: 64a70a27805081a4142f0dea275f37c55cf818207b49e5396da3488bb0602341
name: python-mqtt-recorder-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for mqtt-recorder
url: https://github.com/rpdswtk/mqtt_recorder
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mqtt-recorder-1.4.0-1.src.rpm
location_href: Packages/python-mqtt-recorder-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Simple cli tool for recording and replaying MQTT messages.



  `pip install mqtt-recorder`


  | Argument               | Description                                              | Required | Default |
  | ---------------------- | -------------------------------------------------------- | -------- | ------- |
  | -h, --help             | Show help                                                |          |         |
  | --host                 | MQTT broker address                                      | x        |         |
  | --port                 | MQTT broker port                                         |          | 1883    |
  | --client_id            | MQTT Client ID                                           |          |         |
  | --mode                 | mode: record/replay                                      | x        |         |
  | --file                 | output/input csv file                                    | x        |         |
  | --loop                 | looping replay                                           |          | false   |
  | --qos                  | Quality of Service that will be used for subscriptions   |          | 0       |
  | --topics               | json file containing selected topics for subscriptions   |          | null    |
  | -t, --topic             | Single topic to subscribe to                             |          | null    |
  | --enable_ssl           | True to enable MQTTs support, False otherwise            |          | False   |
  | --tls_insecure         | If certs is self-generated, change to True               |          | False   |
  | --ca_cert              | Path to the Certificate Authority certificate files      |          | None    |
  | --certfile             | Path to the client certificate                           |          | None    |
  | --keyfile              | Path to the client private key                           |          | None    |
  | --username             | MQTT broker username                                     |          | None    |
  | --password             | MQTT broker password                                     |          | None    |
  | --encode_b64           | True to store message payloads as base64 encoded strings |          | False   |
  | --csv_field_size_limit | CSV field size limit                                     |          | False   |



  `mqtt-recorder --host localhost --mode record --file recording.csv`

  `mqtt-recorder --host localhost --mode record --file test.csv --topics topics.json`<br>
  Topics can be selected using a json file.
  Example
  ```json
  {
      "topics": [
          "/myhome/groundfloor/livingroom/temperature",
          "USA/California/San Francisco/Silicon Valley"
      ]
  }
  ```

  `mqtt-recorder --host localhost --mode replay --file test.csv`

rpm_license:
  MIT License  Copyright (c) 2020 RPDSWTK  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: 5f7da315df9f36da6595943efb5df1ebc3d04be233d02a80fda96881d237c112
name: python-mr-star-ble-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for mr-star-ble
url: https://pypi.org/project/mr-star-ble/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mr-star-ble-0.4.0-1.src.rpm
location_href: Packages/python-mr-star-ble-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  This library allows you to control BLE devices supported by MR Star application via Python.



  ```bash
  pip install mr_star_ble
  ```



  ```python
  import asyncio
  from mr_star_ble import MrStarLight

  async def main():
      
      device = await MrStarLight.discover()
      await device.connect()
      
      await device.set_power(False)
      await device.set_brightness(0.01)
      await device.set_rgb_color((255, 0, 0))

  asyncio.run(main())
  ```


pkgId: e5fc4dfff12041c9cc9d780d8f39c8fab4b2f3a6509edbd7efaef373c2ecbfd1
name: python-mrack-help
arch: noarch
version: 1.23.1
epoch: 0
release: 1
summary: Development documents and examples for mrack
url: https://github.com/neoave/mrack
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mrack-1.23.1-1.src.rpm
location_href: Packages/python-mrack-help-1.23.1-1.noarch.rpm
checksum_type: sha256
description:
  **NOTE**
  Above command will install `mrack` package which depends on (contains) following packages:
  - mrack-cli
  - python3-mracklib
  - python3-mrack-aws
  - python3-mrack-beaker
  - python3-mrack-openstack
  - python3-mrack-podman
  - python3-mrack-virt
  The `python3-mracklib` is mandatory as it contains core mrack library.
  To install only some of `mrack` providers you should install `python3-mrack-{provider_name}`.


pkgId: 888f6abd7bd1e601adab8b20b1af264ee34d49de3275ff3339fcde6856ce12cc
name: python-mrgrain.cdk-esbuild-help
arch: noarch
version: 5.3.3
epoch: 0
release: 1
summary: Development documents and examples for mrgrain.cdk-esbuild
url: https://github.com/mrgrain/cdk-esbuild
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mrgrain.cdk-esbuild-5.3.3-1.src.rpm
location_href: Packages/python-mrgrain.cdk-esbuild-help-5.3.3-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/mrgrain/cdk-esbuild/main/images/wordmark.svg" alt="cdk-esbuild">

  *CDK constructs for [esbuild](https://github.com/evanw/esbuild), an extremely fast JavaScript bundler*

  [Getting started](#getting-started) |
  [Documentation](#documentation) | [API Reference](#api-reference) | [Python, .NET, & Go](#python-net-go) | [FAQ](#faq)

  [![View on Construct Hub](https://constructs.dev/badge?package=%40mrgrain%2Fcdk-esbuild)](https://constructs.dev/packages/@mrgrain/cdk-esbuild)



  *esbuild* is an extremely fast bundler and minifier for TypeScript and JavaScript.
  This package makes *esbuild* available to deploy AWS Lambda Functions, static websites or publish assets for further usage.

  AWS CDK [supports *esbuild* for AWS Lambda Functions](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-nodejs-readme.html), but the implementation cannot be used with other Constructs and doesn't expose all of *esbuild*'s API.



  Install `cdk-esbuild` for Node.js using your favorite package manager:

  ```sh

  npm install @mrgrain/cdk-esbuild@5

  yarn add @mrgrain/cdk-esbuild@5

  pnpm add @mrgrain/cdk-esbuild@5
  ```

  For Python, .NET or Go, use these commands:

  ```sh

  pip install mrgrain.cdk-esbuild


  dotnet add package Mrgrain.CdkEsbuild


  go get github.com/mrgrain/cdk-esbuild-go/cdkesbuild/v5
  ```



  > 💡 See [Lambda (TypeScript)](examples/typescript/lambda) and [Lambda (Python)](examples/typescript/lambda) for working examples of a how to deploy an AWS Lambda Function.

  Use `TypeScriptCode` as the `code` of a [lambda function](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html#code):

  ```python
  const bundledCode = new TypeScriptCode("src/handler.ts");

  const fn = new lambda.Function(stack, "MyFunction", {
    runtime: lambda.Runtime.NODEJS_18_X,
    handler: "index.handler",
    code: bundledCode,
  });
  ```



  > 💡 See [React App (TypeScript)](examples/typescript/website) for a working example of a how to deploy a React app to S3.

  Use `TypeScriptSource` as one of the `sources` of a [static website deployment](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3-deployment-readme.html#roadmap):

  ```python
  const websiteBundle = new TypeScriptSource("src/index.tsx");

  const websiteBucket = new s3.Bucket(stack, "WebsiteBucket", {
    autoDeleteObjects: true,
    publicReadAccess: true,
    removalPolicy: cdk.RemovalPolicy.DESTROY,
    websiteIndexDocument: "index.html",
  });

  new s3deploy.BucketDeployment(stack, "DeployWebsite", {
    destinationBucket: websiteBucket,
    sources: [websiteBundle],
  });
  ```



  > 💡 See [Monitored Website (TypeScript)](examples/typescript/website) for a working example of a deployed and monitored website.

  Synthetics runs a canary to produce traffic to an application for monitoring purposes. Use `TypeScriptCode` as the `code` of a Canary test:

  ```python
  const bundledCode = new TypeScriptCode("src/canary.ts", {
    buildOptions: {
      outdir: "nodejs/node_modules", // This is required by AWS Synthetics
    },
  });

  const canary = new synthetics.Canary(stack, "MyCanary", {
    runtime: synthetics.Runtime.SYNTHETICS_NODEJS_PUPPETEER_5_1,
    test: synthetics.Test.custom({
      code: bundledCode,
      handler: "index.handler",
    }),
  });
  ```



  The package exports constructs for use with AWS CDK features.
  The guiding design principal of this package is *"extend, don't replace"*.
  Expect constructs that you can provide as props, not complete replacements.

  For use with **Lambda Functions** and **Synthetic Canaries**, implementing `lambda.Code` ([reference](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Code.html)) and `synthetics.Code` ([reference](https://docs.aws.amazon.com/cdk/api/v2/docs/@aws-cdk_aws-synthetics-alpha.Code.html)):

  * `TypeScriptCode`

  Inline code is only supported by **Lambda**:

  * `InlineTypeScriptCode`

  For use with **S3 bucket deployments**, implementing `s3deploy.ISource` ([reference](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3-deployment-readme.html)):

  * `TypeScriptSource`

  > *`Code` and `Source` constructs seamlessly plug-in to other high-level CDK constructs. They share the same set of parameters, props and build options.*

  The following classes power the other features. You normally won't have to use them, but they are there if you need them:

  * `TypeScriptAsset` implements `s3.Asset` ([reference](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3_assets.Asset.html)) \
    creates an asset uploaded to S3 which can be referenced by other constructs
  * `EsbuildBundler` implements `core.BundlingOptions` ([reference](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.BundlingOptions.html)) \
    provides an interface for a *esbuild* bundler wherever needed
  * `EsbuildProvider` implements `IBuildProvider` and `ITransformProvider` \
    provides the default *esbuild* API implementation and can be replaced with a custom implementation



  Auto-generated reference for Constructs, Classes and Structs.
  This information is also available as part of your IDE's code completion.



  *Esbuild* requires a platform and architecture specific binary and currently has to be installed with a Node.js package manager like npm.

  When using `cdk-esbuild` with Python, .NET or Go, the package will automatically detect local and global installations of the *esbuild* npm package.
  If none can be found, it will fall back to dynamically installing a copy into a temporary location.
  The exact algorithm of this mechanism must be treated as an implementation detail and should not be relied on.
  It can however be configured to a certain extent.
  See the examples below for more details.

  This "best effort" approach makes it easy to get started.
  But is not always desirable, for example in environments with limited network access or when guaranteed repeatability of builds is a concern.
  You have several options to opt-out of this behavior.



  The first step is to install a version of *esbuild* that is controlled by you.

  I **strongly recommend** to install *esbuild* as a local package.
  The easiest approach is to manage an additional Node.js project at the root of your AWS CDK project.
  *esbuild* can then be added to the `package.json` file and it is your responsibility to ensure required setup steps are taken in all environments like development machines and CI/CD systems.

  Instead of installing the *esbuild* package in a local project, it can also be **installed globally** with `npm install -g esbuild` or a similar command.
  This approach might be preferred if a build container is prepared ahead of time, thus avoiding repeated package installation.



  The second step is to make `cdk-esbuild` aware of your chosen install location.
  This step is optional, but it's a good idea to have the location or at least the method explicitly defined.

  To do this, you can set the `esbuildModulePath` prop on a `EsbuildProvider`.
  Either pass a known, absolute or relative path as value, or use the `EsbuildSource` helper to set the detection method.
  Please refer to the [`EsbuildSource`](API.md#esbuildsource) reference for a complete list of available methods.

  ```python
  // Use the standard Node.js algorithm to detect a locally installed package
  new EsbuildProvider({
    esbuildModulePath: EsbuildSource.nodeJs(),
  });

  // Provide an explicit path
  new EsbuildProvider({
    esbuildModulePath: '/home/user/node_modules/esbuild/lib/main.js',
  });
  ```

  As a no-code approach, the `CDK_ESBUILD_MODULE_PATH` environment variable can be set in the same way.
  An advantage of this is that the path can easily be changed for different systems.
  Setting the env variable can be used with any installation approach, but is typically paired with a global installation of the *esbuild* package.
  Note that `esbuildModulePath` takes precedence.



  For an AWS CDK app with many instances of `TypeScriptCode` etc. it would be annoying to change the above for every single one of them.
  Luckily, the default can be changed for all usages per app:

  ```python
  const customModule = new EsbuildProvider({
    esbuildModulePath: EsbuildSource.globalPaths(),
  });
  EsbuildProvider.overrideDefaultProvider(customModule);
  ```



  This package uses the *esbuild* JavaScript API.
  In most situations the default API configuration will be suitable.
  But sometimes it is required to configure *esbuild* differently or even provide a custom implementation.
  Common reasons for this are:

  * Using a pre-installed version of *esbuild* with Python, .NET or Go
  * If features not supported by the synchronous API are required, e.g. support for plugins
  * If the default version constraints for *esbuild* are not suitable
  * To use a version of esbuild that is installed by any other means than `npm`, including Docker

  For these scenarios, this package offers customization options and an interface to provide a custom implementation:

  ```python
  declare const myCustomBuildProvider: IBuildProvider;

  new TypeScriptCode("src/handler.ts", {
    buildProvider: myCustomBuildProvider,
  });


  declare const myCustomTransformProvider: ITransformProvider;

  new InlineTypeScriptCode("let x: number = 1", {
    transformProvider: myCustomTransformProvider,
  });
  ```



  It is possible to override the binary used by *esbuild* by setting a property on `EsbuildProvider`.
  This is the same as setting the `ESBUILD_BINARY_PATH` environment variable.
  Defining the `esbuildBinaryPath` prop takes precedence.

  ```python
  const buildProvider = new EsbuildProvider({
    esbuildBinaryPath: "path/to/esbuild/binary",
  });

  // This will use a different esbuild binary
  new TypeScriptCode("src/handler.ts", { buildProvider });
  ```



  The Node.js module discovery algorithm will normally be used to find the *esbuild* package.
  It can be useful to use specify a different module path, for example if a globally installed package should be used instead of a local version.

  ```python
  const buildProvider = new EsbuildProvider({
    esbuildModulePath: "/home/user/node_modules/esbuild/lib/main.js",
  });

  // This will use a different esbuild module
  new TypeScriptCode("src/handler.ts", { buildProvider });
  ```

  Alternatively supported by setting the `CDK_ESBUILD_MODULE_PATH` environment variable, which will apply to all uses.
  Defining the `esbuildModulePath` prop takes precedence.

  If you are a Python, .NET or Go user, refer to the language specific guide for a more detailed explanation of this feature.



  > 💡 See [esbuild plugins w/ TypeScript](examples/typescript/esbuild-with-plugins) for a working example of a custom Build API implementation.

  A custom implementation can be provided by implementing `IBuildProvider` or `ITransformProvider`:

  ```python
  class CustomEsbuild implements IBuildProvider, ITransformProvider {
      buildSync(options: BuildOptions): void {
        // custom implementation goes here
      }

      transformSync(code: string, options?: TransformOptions): string {
        // custom implementation goes here, return transformed code
        return 'transformed code';
      }
  }

  // These will use the custom implementation
  new TypeScriptCode("src/handler.ts", {
    buildProvider: new CustomEsbuild(),
  });
  new InlineTypeScriptCode("let x: number = 1", {
    transformProvider: new CustomEsbuild(),
  });
  ```

  Instead of *esbuild*, the custom methods will be invoked with all computed options.
  Custom implementations can amend, change or discard any of the options.

  The `IBuildProvider` integration with CDK relies on the `outdir`/`outfile` values and it's usually required to use them unchanged.

  `ITransformProvider` must return the transformed code as a string.

  Failures and warnings should be printed to stderr and thrown as the respective *esbuild* error.



  The default implementation can also be set for all usages of `TypeScriptCode` etc. in an AWS CDK app.
  You can change the default for both APIs at once or set a different implementation for each of them.

  ```python
  const myCustomEsbuildProvider = new MyCustomEsbuildProvider();

  EsbuildProvider.overrideDefaultProvider(myCustomEsbuildProvider);
  EsbuildProvider.overrideDefaultBuildProvider(myCustomEsbuildProvider);
  EsbuildProvider.overrideDefaultTransformationProvider(myCustomEsbuildProvider);

  // This will use the custom provider without the need to define it as a prop
  new TypeScriptCode("src/handler.ts");
  ```



  [The project's roadmap is available on GitHub.](https://github.com/users/mrgrain/projects/1/views/7)

  Please submit feature requests as issues to the repository.
  All contributions are welcome, no matter if they are for already planned or completely new features.





  This package is stable and ready to be used in production, as many do.
  However *esbuild* has not yet released a version 1.0.0 and its API is still in active development.
  Please read the guide on [esbuild's production readiness](https://esbuild.github.io/faq/#production-readiness).

  Note that *esbuild* minor version upgrades are also introduced in **minor versions** of this package.
  Since *esbuild* is pre v1, these versions typically introduce breaking changes and this package will inherit them.
  To avoid this behavior, add the desired *esbuild* version as a dependency to your package.



  Please refer to the [v5 release notes](https://github.com/mrgrain/cdk-esbuild/releases/tag/v5.0.0) for a list of backwards incompatible changes and respective upgrade instructions.



  This package depends on *esbuild* as an optional dependencies. If optional dependencies are not installed automatically on your system (e.g. when using npm v4-6), install *esbuild* explicitly:

  ```console
  npm install esbuild
  ```



  Use the [override](https://docs.npmjs.com/cli/v9/configuring-npm/package-json?v=true#overrides) instructions for your package manager to force a specific version, for example:

  ```json
  {
    "overrides": {
      "esbuild": "0.14.7"
    }
  }
  ```

  Build and Transform interfaces are relatively stable across *esbuild* versions.
  However if any incompatibilities occur, `buildOptions` / `transformOptions` can be cast to `any`:

  ```python
  const bundledCode = new TypeScriptCode("src/handler.ts", {
    buildOptions: {
      unsupportedOption: "value"
    } as any,
  });
  ```



  Install the desired version of *esbuild* locally or globally [as described in the documentation above](#python-net-go).

  Build and Transform interfaces are relatively stable across *esbuild* versions.
  However if any incompatibilities occur, use the appropriate language features to cast any incompatible `buildOptions` / `transformOptions` to the correct types.



  It is possible to use `cdk-esbuild` in a published AWS CDK Construct library, but not recommended.
  Always prefer to ship a compiled `.js` file or even bundle a zip archive in your package.
  For AWS Lambda Functions, [projen provides an excellent solution](https://projen.io/awscdk.html#aws-lambda-functions).

  If you do end up consuming `cdk-esbuild`, you will have to set `buildOptions.absWorkingDir`. The easiest way to do this, is to resolve the path based on the directory name of the calling file:

  ```js
  // file: node_modules/construct-library/src/index.ts
  const props = {
    buildOptions: {
      absWorkingDir: path.resolve(__dirname, ".."),
      // now: /user/local-app/node_modules/construct-library
    },
  };
  ```

  This will dynamically resolve to the correct path, wherever the package is installed.
  Please open an issue if you encounter any difficulties.



  Yes, `v2` of `cdk-esbuild` is compatible with AWS CDK v1.
  You can find the [documentation for it on the v2 branch](https://github.com/mrgrain/cdk-esbuild/tree/v2).

  Support for AWS CDK v1 and `cdk-esbuild` v2 has ended on June 1, 2023.
  Both packages are not receiving any updates or bug fixes, including for security related issues.
  You are strongly advised to upgrade to a supported version of these packages.


pkgId: 34454137e84857fe39d5a57e85c7202b2a23d8c8f6c1df367571f4f870278409
name: python-mri2mesh-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mri2mesh
url: https://github.com/kent-and/mri2mesh
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mri2mesh-0.1.0-1.src.rpm
location_href: Packages/python-mri2mesh-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains a pipeline to generate surfaces from voxelized data using `scikit-image` and `pyvista`. It also contains tools for visualization using `pyvista`.



  To install the required packages, run:

  ```bash
  python3 -m pip install git+https://github.com/scientificcomputing/mri2mesh.git
  ```


  The basic using is through the command line using the command `mri2mesh`. To see all the options, run:

  ```bash
  mri2mesh --help
  ```


  Visualization is achieved through the subcommand `viz`. To see all options you can do

  ```bash
  mri2mesh viz --help
  ```

  For example to visualize a nifty file called `T1_synthseg.nii.gz`, run:

  ```bash
  mri2mesh viz volume-clip -i T1_synthseg.nii.gz
  ```
  which will open up the volume with a clipping plane. To see all the options, run:

  ```bash
  mri2mesh viz volume-clip --help
  ```


  To generate the parenchyma surface from a nifty file, run:

  ```bash
  mri2mesh surface parenchyma -i T1_synthseg.nii.gz
  ```


  The pipeline is developed by Marius Causemann and Henrik Finsberg.



  MIT


pkgId: b3c12e7cae2b02ff7ffc169bf869a24eeb4b97bed43f1095e20d154c14700443
name: python-mrpro-help
arch: noarch
version: 0.241217
epoch: 0
release: 1
summary: Development documents and examples for mrpro
url: https://pypi.org/project/mrpro/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mrpro-0.241217-1.src.rpm
location_href: Packages/python-mrpro-help-0.241217-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
  <img src="docs/source/_static/logo.svg" alt="MRpro logo" width="50%">
  </h1><br>

  ![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  ![Coverage Bagde](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/ckolbPTB/48e334a10caf60e6708d7c712e56d241/raw/coverage.json)

  MR image reconstruction and processing package specifically developed for PyTorch.

  - **Source code:** <https://github.com/PTB-MR/mrpro>
  - **Documentation:** <https://ptb-mr.github.io/mrpro/>
  - **Bug reports:** <https://github.com/PTB-MR/mrpro/issues>
  - **Try it out:** [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/PTB-MR/mrpro.git/main?labpath=examples)



  - 2024 ISMRM QMRI Study Group Challenge, 2nd prize for Relaxometry (T2* and T1)



  - **ISMRMRD support** MRpro supports [ismrmrd-format](https://ismrmrd.readthedocs.io/en/latest/) for MR raw data.
  - **PyTorch** All data containers utilize PyTorch tensors to ensure easy integration in PyTorch-based network schemes.
  - **Cartesian and non-Cartesian trajectories** MRpro can reconstruct data obtained with Cartesian and non-Cartesian (e.g. radial, spiral...) sapling schemes. MRpro automatically detects if FFT or nuFFT is required to reconstruct the k-space data.
  - **Pulseq support** If the data acquisition was carried out using a [pulseq-based](http://pulseq.github.io/) sequence, the seq-file can be provided to MRpro and the used trajectory is automatically calculated.
  - **Signal models** A range of different MR signal models are implemented (e.g. T1 recovery, WASABI).
  - **Regularized image reconstruction** Regularized image reconstruction algorithms including Wavelet-based compressed sensing or total variation regularized image reconstruction are available.



  In the following, we show some code snippets to highlight the use of MRpro. Each code snippet only shows the main steps. A complete working notebook can be found in the provided link.



  Read the data and trajectory and reconstruct an image by applying a density compensation function and then the adjoint of the Fourier operator and the adjoint of the coil sensitivity operator.

  ```python

  trajectory = mrpro.data.traj_calculators.KTrajectoryIsmrmrd()

  kdata = mrpro.data.KData.from_file(data_file.name, trajectory)

  reconstruction = mrpro.algorithms.reconstruction.DirectReconstruction.from_kdata(kdata)
  img = reconstruction(kdata)
  ```

  Full example: <https://github.com/PTB-MR/mrpro/blob/main/examples/direct_reconstruction.py>



  Quantitative parameter maps can be obtained by creating a functional to be minimized and calling a non-linear solver such as ADAM.

  ```python

  model = MagnitudeOp() @ InversionRecovery(ti=idata_multi_ti.header.ti)

  mse = MSE(idata_multi_ti.data.abs())
  functional = mse @ model
  [...]

  params_result = adam(functional, [m0_start, t1_start], max_iter=max_iter, lr=lr)
  ```

  Full example: <https://github.com/PTB-MR/mrpro/blob/main/examples/qmri_sg_challenge_2024_t1.py>



  The trajectory can be calculated directly from a provided pulseq-file.

  ```python

  kdata = KData.from_file(data_file.name, KTrajectoryPulseq(seq_path=seq_file.name))
  ```

  Full example: <https://github.com/PTB-MR/mrpro/blob/main/examples/pulseq_2d_radial_golden_angle.py>



  We are looking forward to your contributions via Pull-Requests.



  1. Clone the MRpro repository
  2. Create/select a python environment
  3. Install "MRpro" in editable mode including test dependencies: ``` pip install -e ".[test]" ```
  4. Setup pre-commit hook: ``` pre-commit install ```

  Please look at our [contributor guide](https://ptb-mr.github.io/mrpro/contributor_guide.html) for more information on the repository structure, naming conventions, and other useful information.


pkgId: 1b31653da3c25b18db8f4d92672d14281626e2c0995e155517f512fc9940a7d3
name: python-ms-salesforce-api-help
arch: noarch
version: 2.17.0
epoch: 0
release: 1
summary: Development documents and examples for ms-salesforce-api
url: https://pypi.org/project/ms-salesforce-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ms-salesforce-api-2.17.0-1.src.rpm
location_href: Packages/python-ms-salesforce-api-help-2.17.0-1.noarch.rpm
checksum_type: sha256
description:
  After clone repository


  ```bash
  poetry install
  ```


  ```bash
  make test
  ```


  ```bash
  make lint && make isort
  ```


  Once we have done a merge of our Pull request and we have the updated master branch we can generate a new version. For them we have 3 commands that change the version of our library and generate the corresponding tag so that the Bitbucket pipeline starts and publishes our library automatically.

  ```bash
  make release-patch
  ```

  ```bash
  make release-minor
  ```

  ```bash
  make release-major
  ```


  This project provides an API for querying Salesforce opportunities data and transforming it into an easy-to-use format. The API is built upon the `SalesforceQueryExecutor` and `Project` classes, with the latter inheriting from `SalesforceQueryExecutor`.



  Make sure you have **Python 3.8+** installed. Then, install the required dependencies using `poetry`:

  ```bash
  poetry install ms-salesforce-api
  ```


  To run the unit tests, simply execute the following command:

  ```bash
  make test
  ```
  This will run all the tests and display the results. Make sure that all tests pass before using the API in a production environment.



  First, import the necessary classes:

  ```python
  from ms_salesforce_api.salesforce.project import Project
  ```

  Then, initialize the `Project` class with your Salesforce credentials:

  ```python
  project = Project(
      client_id="your_client_id",
      username="your_username",
      domain="your_domain",
      private_key="your_private_key",
      audience="https://login.salesforce.com", # Default value
      session_duration_hours=1, # Default value
      api_version='57.0',  # Default value
  )
  ```

  Now, you can call the get_all method with a query to get the opportunities data:

  ```python
  opportunities = project.get_all()
  ```

  The opportunities variable will contain an array of opportunity objects with the transformed data. For example:

  ```python
  [
   {
      "account_assigment_group": None,
      "account_billing_address": "C/ XXX XXX, 8 Planta 9ª, 28020, Spain",
      "account_billing_city": None,
      "account_billing_country": "ES",
      "account_billing_postal_code": "28020",
      "account_billing_state_code": None,
      "account_billing_street": "C/ XXX XXX, 8 Planta 9ª",
      "account_business_function": "XXXX",
      "account_business_name": "XXXXXX",
      "account_cif": "ESXXXXXXX",
      "account_company_invoicing": "2411",
      "account_created_date": "2022-03-28T09:05:44.000+0000",
      "account_currency_code": "",
      "account_fax": None,
      "account_invoicing_email": None,
      "account_mail_invoicing": None,
      "account_name": "XXXXXXXX",
      "account_office": "XXXXXXXX",
      "account_payment_terms": "T030",
      "account_pec_email": None,
      "account_phone": None,
      "account_sap_id": "10001210",
      "account_tax_category": None,
      "account_tax_classification": None,
      "account_tax_id_type": "ES0",
      "account_tier": "T1",
      "account_website": None,
      "amount": 0,
      "billing_lines": [
          {
              "billing_amount": 274.33,
              "billing_date": "2022-01-31",
              "billing_period_ending_date": "2022-03-31",
              "billing_period_starting_date": "2022-01-01",
              "billing_plan_amount": "274.33",
              "billing_plan_billing_date": "2022-01-31",
              "billing_plan_item": "0",
              "billing_plan_service_end_date": "2022-03-31",
              "billing_plan_service_start_date": "2022-01-01",
              "created_date": "2022-07-08T10:07:08.000+0000",
              "currency": "EUR",
              "hourly_price": None,
              "id": "XXXXXXXXXXXX",
              "last_modified_date": "2023-05-04T12:24:25.000+0000",
              "name": "BL-XXXXXXXX",
              "project_id": "YYYYYYYYYYYYY",
              "revenue_dedication": None,
          }
      ],
      "controller_email": "employee@makingscience.com",
      "controller_sub_email": "",
      "cost_center": "0220001800",
      "created_at": "2021-10-06T14:35:18.000+0000",
      "currency": "EUR",
      "invoicing_country_code": "ES",
      "jira_task_url": "<a href=https://makingscience.atlassian.net/browse/ESMSBD0001-1080 target=_blank>View Jira Task</a>",
      "last_updated_at": "2023-06-08T11:22:55.000+0000",
      "lead_source": "Employee Referral",
      "operation_coordinator_email": "employee@makingscience.com",
      "operation_coordinator_sub_email": "",
      "opportunity_name": "Branding Campaign",
      "opportunity_percentage": 100.0,
      "profit_center": "200018",
      "project_code": "ESMSEX01652",
      "project_id": "a003X00001WS2YHQA1",
      "project_line_items": [
          {
              "country": "Spain",
              "created_date": "2022-05-05T12:28:48.000+0000",
              "effort": None,
              "ending_date": "2022-03-31",
              "id": "a0V7U000001OdiUUAS",
              "last_modified_date": "2023-06-08T11:20:42.000+0000",
              "ms_pli_name": "Omnichannel_ESMSEx01652_ES",
              "product_name": "Advertising Lead Gen Proj",
              "quantity": None,
              "starting_date": "2022-01-01",
              "total_price": 0.0,
              "unit_price": 2230.99,
          }
      ],
      "project_name": "BrandingCampaignPilotESMSEx01652",
      "project_start_date": "2021-12-01",
      "project_tier": "Unkown",
      "stage": "Closed Won",
  }
  ]
  ```

  You can customize the query as needed to retrieve different data from Salesforce.

  ```python
  query = "SELECT Id, Name FROM Project WHERE Project.Id = 'ESMS0000'"

  opportunities = project.get_all(query=query)
  ```


  This library allow to export all opportunities data to a external database such Postgres and BigQuery.
  Podemos importar cualquiera de las clases:

  ```python

  from ms_salesforce_api.salesforce.api.project.export_data.Bigquery import (
      BigQueryExporter,
  )
  ```

  o

  ```python

  from ms_salesforce_api.salesforce.api.project.export_data.CloudSQL import (
      CloudSQL
  )
  ```

  Both classes, when initialized, are in charge of creating the databases and the tables to export the data in case they do not exist.



  The Bigquery class provides functionalities to export data to Google BigQuery.

  |   ℹ️   |   Información   |
  |:------:|:--------------:|
  |    | The "BigqueryExporter" class needs an environment variable named "**GOOGLE_SERVICE_ACCOUNT_CREDENTIALS**" to exist and its value must be the JSON of the **Service Account** that has permissions to write to **BigQuery** and must be in **base64**|


  ```python
  class BigqueryExporter:
      def __init__(self, project_id: str, dataset_id: str):
          """
          Initializes the Bigquery exporter with the given project ID and dataset ID.

          Args:
              project_id (str): The ID of the Google Cloud project.
              dataset_id (str): The ID of the BigQuery dataset.
          """
  ```


  * **export_data**(data: List[Dict[str, Any]]) -> None
  Exports the provided data to BigQuery.

      * data (List[Dict[str, Any]]): This variable has the value of "opportunities" returned by the "get_all" method.


  * **delete_all_rows**() -> None
  Delete all data for each table (Opportunities, Accounts, Billing line and PLIs). In this way we can have the database updated at all times.




  The CloudSQL class provides functionalities to interact with a Google Cloud SQL database.


  Constructor

  ```python
  class CloudSQL:
       def __init__(self, host, user, password, dbname, debug_mode=False):
          """
          Connect with a Postgres Database with the given
          host name, database name, username, and password.

          Args:
              host (str): The host name for the Postgres database.
              user (str): The username for accessing the database.
              password (str): The password for accessing the database.
              dbname (str): The name of the database.
          """
  ```



  * **export_data**(data: List[Dict[str, Any]]) -> None
  Exports the provided data to BigQuery.

      * data (List[Dict[str, Any]]): This variable has the value of "opportunities" returned by the "get_all" method.


  * **delete_all_rows**() -> None
  Delete all data for each table (Opportunities, Accounts, Billing line and PLIs). In this way we can have the database updated at all times.


