# packages

pkgId: c964070fba6fc08e4d723d6169f8a06bd6f58a37d0b67f44b8acc460f2b8d24f
name: python-lute3-help
arch: noarch
version: 3.6.1
epoch: 0
release: 1
summary: Development documents and examples for lute3
url: https://pypi.org/project/lute3/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lute3-3.6.1-1.src.rpm
location_href: Packages/python-lute3-help-3.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Learning Using Texts v3.

  Lute is for learning foreign languages through reading.  `lute3` is a rewrite of the original Lute PHP application in Python and Flask.  See the [Lute manual](https://luteorg.github.io/lute-manual/) for more detail, and notes about installation.




  Python 3.8+ (tested with python 3.8 through 3.11)

  Japanese learners will also need to install MeCab.



  `lute3` installs various dependencies, so you should install it in a virtual environment.  For example, using `venv`:

  Create a new folder (e.g. `lute3`) anywhere on your system.

  ```

  python3.8 -m venv myenv


  source myenv/bin/activate




  pip install lute3


  python -m lute.main





  deactivate
  ```

  Once everything is installed, for future runs you'll just need to go into `lute3` folder created above and:

  ```
  source myenv/bin/activate
  python -m lute.main
  ```


pkgId: 665f992e50da69f4221750d85a4161d74413fc255a518efab881a04878752f95
name: python-luxtelligence-lnoi400-forge-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for luxtelligence-lnoi400-forge
url: https://pypi.org/project/luxtelligence-lnoi400-forge/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-luxtelligence-lnoi400-forge-1.1.1-1.src.rpm
location_href: Packages/python-luxtelligence-lnoi400-forge-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This python module implements the [Luxtelligence](https://luxtelligence.ai/)
  LNOI400 PDK as components and technology specification for
  [PhotonForge](https://docs.flexcompute.com/projects/photonforge/)




  Installation via `pip`:

      pip install luxtelligence-lnoi400-forge




  1. [Download from
     PyPI](https://pypi.org/project/luxtelligence-lnoi400-forge/#files) the
     latest wheel file: `luxtelligence_lnoi400_forge-*-py3-none-any.whl`.

  2. In the PhotonForge web interface, upload that file to load the LNOI400 PDK.




  The simplest way to use the this PDK in PhotonForge is to set its technology as
  default:

      import photonforge as pf
      import luxtelligence_lnoi400_forge as lxt

      tech = lxt.lnoi400()
      pf.config.default_technology = tech


  The `lnoi400` function creates a parametric technology and accepts a number of
  parameters to fine-tune the technology.

  PDK components are available in the `component` submodule. The list of
  components can be discovered by:

      dir(lxt.component)

      pdk_component = lxt.component.mmi1x2()


  Utility functions `cpw_spec` and `place_edge_couplers` are also available for
  generating CPW port specifications and placing edge couplers at chip boudaries.

  More information can be obtained in the documentation for each function:

      help(lxt.lnoi400)

      help(lxt.component.mmi1x2)

      help(lxt.place_edge_couplers)




  Please note that the 3D structures obtained by extrusion through this module's
  technologies are a best approximation of the intended fabricated structures,
  but the actual final dimensions may differ due to several fabrication-specific
  effects. In particular, doping profiles are represented with hard-boundary,
  homogeneous solids, but, in practice will present process-dependent variations
  with smooth boundaries.


pkgId: e75ff47f21a07213839df26f1335acea5397d22e744da99637f65f61ea04e3b0
name: python-luxy
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: A Python wrapper for Yale's Lux API, provided by Yale University.
url: https://github.com/project-lux/pylux
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-luxy-0.0.5-1.src.rpm
location_href: Packages/python-luxy-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  ![Lux Logo](https://github.com/project-lux/luxy/blob/main/docs/images/luxy-logo.jpg?raw=true)

  [![PyPI version](https://badge.fury.io/py/luxy.svg)](https://badge.fury.io/py/luxy)
  [![GitHub stars](https://img.shields.io/github/stars/project-lux/luxy.svg)](https://github.com/project-lux/luxy/stargazers)
  [![GitHub release](https://img.shields.io/github/v/release/project-lux/luxy)](https://github.com/project-lux/luxy/releases)


  LuxY is a Python wrapper for Yale's [Lux API](https://lux.collections.yale.edu/). Lux allows users to search and filter the collections of Yale's museums and libraries, as well as external collections. This lets you find and connect with the cultural heritage collections across Yale's museums, archives, and libraries in new ways and all in one place.

  LuxY gives you a Pythonic way to interact with the Lux API, making it easier to search and filter the collections and even download the data in JSON format. It can handle pagination, nested filters, and more.



  To get started, install LuxY using pip:

  ```bash
  pip install luxy
  ```



  The classes of LuxY replicate the classes of the Lux API. They are:

  1. PeopleGroups (agent) - People and Groups that are either individuals or organizations
  2. Objects (item) - Physical objects in Yale's collections
  3. Works (work) - Visual and textual works, including images, texts, and other creative expressions
  4. Places (place) - Geographic locations and named spaces
  5. Concepts (concept) - Types, materials, languages, measurement units, currencies and other conceptual entities
  6. Events (event) - Historical events and occurrences
  7. Collections (set) - Collections and sets of objects curated by Yale's institutions

  Each of these has common and unique filters that take different data types, from strings to numbers to dates. LuxY also supports nested filters, which are used to filter by multiple levels of the hierarchy. This allows users to create complex queries similar to the ones found in the Lux UI.



  Each filter has a set of options that can be used to filter the data. These options are stored in the `get_options()` method.

  ```python
  from luxy import PeopleGroups

  options = PeopleGroups().get_options()
  print(options)


  PeopleGroups().list_filters()
  ```



  ```python
  from luxy import PeopleGroups

  result = PeopleGroups().filter(name="Rembrandt").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  ```python
  from luxy import Objects

  result = Objects().filter(name="Rembrandt").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  ```python
  from luxy import Works

  result = Works().filter(name="Painting").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  ```python
  from luxy import Places

  result = Places().filter(name="Amsterdam").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  ```python
  from luxy import Concepts

  result = Concepts().filter(name="gilding").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  ```python
  from luxy import Events

  result = Events().filter(name="Thirty Years War").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  ```python
  from luxy import Collections

  result = Collections().filter(name="Letters").get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  Numerical filters are a bit tricky because they require a tuple with the value and the comparison operator.

  ```python
  from luxy import Objects

  result = Objects().filter(height=(1, ">=")).get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```



  Date filters are a bit tricky because they require a tuple with the value and the comparison operator. The value should be a string in the format of `YYYY-MM-DDTHH:MM:SS.SSSZ`.

  ```python
  from luxy import Objects

  result = Objects().filter(encounteredDate=("1987-01-01T00:00:00.000Z", ">=")).get()
  print(result.url)
  print(result.view_url)
  print(result.json)
  ```


  ```python
  from luxy import PeopleGroups

  result = (
      PeopleGroups()
      .filter(recordType="person")
      .filter(hasDigitalImage=True)
      .filter(text="rembrandt")
      .filter(gender={"name": "male"})
      .get()
  )


  print("Number of results:", result.num_results)


  print("URL:", result.url)


  print("JSON:", result.json)
  ```



  ```bash
  Number of results: 131
  URL: https://lux.collections.yale.edu/api/search/agent?q=%7B%22AND%22%3A%20%5B%7B%22recordType%22%3A%20%22person%22%7D%2C%20%7B%22hasDigitalImage%22%3A%201%7D%2C%20%7B%22text%22%3A%20%22rembrandt%22%7D%2C%20%7B%22gender%22%3A%20%7B%22id%22%3A%20%22https%3A//lux.collections.yale.edu/data/concept/6f652917-4c07-4d51-8209-fcdd4f285343%22%7D%7D%5D%7D
  JSON: {'@context': 'https://linked.art/ns/v1/search.json'...
  ```



  ```python
  from luxy import PeopleGroups

  result = (
      PeopleGroups()
      .filter(endAt={"name": "Amsterdam"})
      .get()
  )


  print("Number of results:", result.num_results)
  print("Number of pages:", result.num_pages())

  for i, page in enumerate(result.get_page_data_all(), 1):
      if i > 2: # Break after 2 pages
          break
      print(f"Page {i}:", page["id"])
      for j, item in enumerate(result.get_items(page)):
          print(f"Item {j}:", result.get_item_data(item)["_label"])
  ```



  ```python
  result = (
      Objects()
      .filter(hasDigitalImage=True)
      .filter(
          OR=[
              Objects().memberOf("Letters", depth=2),
              Objects().memberOf("Letters", depth=3),
              Objects().memberOf("Letters", depth=4)
          ]
      )
      .filter(name="letter")
      .get()
  )

  print(result.url)
  print(result.json)
  ```






  - [x] Add support for People/Groups
      - [ ] Filter by:
          - [x] Has Digital Image
          - [x] Gender
          - [x] Nationality (nationality)
          - [x] Person or Group Class
          - [x] Categorized As (classification)
          - [x] Born/Formed At (startAt)
          - [x] Born/Formed Date
          - [x] Carried Out (carriedOut)
          - [x] Created Object (produced)
          - [x] Created Works (created)
          - [x] Curated (curated)
          - [x] Died/Dissolved At (endAt)
          - [x] Died/Dissolved Date
          - [x] Encountered
          - [x] Founded By
          - [x] Founded Group
          - [x] Have Member
          - [x] ID
          - [x] Identifier
          - [x] Influenced (influenced)
          - [x] Influenced Creation Of Objects
          - [x] Influenced Creation Of Works
          - [x] Member Of (memberOf)
          - [x] Occupation/Role (occupation)
          - [x] Professional Activity Categorized As (professionalActivity)
          - [x] Professionally Active At (activeAt)
          - [x] Professionally Active Date
          - [x] Published (published)
          - [x] Subject Of
  - [x] Add support for Objects
  - [x] Add support for Works
  - [x] Add support for Places
  - [x] Add support for Concepts
  - [x] Add support for Events
  - [x] Add support for Pagination
  - [x] Add support for Downloading Page JSON
  - [x] Add support for Downloading Item JSON
  - [x] Add more filters
  - [x] Add support for date filters
  - [x] Add support for numbers
      - [x] Greater Than
      - [x] Less Than
      - [x] Greater Than or Equal To
      - [x] Less Than or Equal To
      - [x] Equal To
      - [x] Not Equal To
  - [x] Add And support for filters
  - [x] Add support for OR filters
  - [x] Add support for have All of # AND
  - [x] Add support for have Any of # OR
  - [x] Add support for have None of # NOT
  - [x] Add more tests
  - [x] Add more documentation
  - [x] Add a check to make sure a filter exists


pkgId: e1a9021105215450f099bc18437b8458306baeba79aeee4b3670045cdd283ed0
name: python-luxy-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for luxy
url: https://github.com/project-lux/pylux
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-luxy-0.0.1-1.src.rpm
location_href: Packages/python-luxy-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Lux Logo](./docs/images/luxy-logo.jpg)

  [![PyPI version](https://badge.fury.io/py/luxy.svg)](https://badge.fury.io/py/luxy)
  [![GitHub stars](https://img.shields.io/github/stars/project-lux/luxy.svg)](https://github.com/project-lux/luxy/stargazers)
  [![GitHub release](https://img.shields.io/github/v/release/project-lux/luxy)](https://github.com/project-lux/luxy/releases)


  LuxY is a Python wrapper for Yale's Lux API. Currently, there is minimal support for the API, but it is in active development.



  **warning** not on pypi yet...

  ```bash
  pip install luxy
  ```



  ```python
  from luxy import PeopleGroups

  result = (
      PeopleGroups()
      .filter(recordType="person")
      .filter(hasDigitalImage=True)
      .filter(text="rembrandt")
      .filter(gender="male")
      .get()
  )


  print("Number of results:", result.num_results)


  print("URL:", result.url)


  print("JSON:", result.json)
  ```



  ```bash
  Number of results: 131
  URL: https://lux.collections.yale.edu/api/search/agent?q=%7B%22AND%22%3A%20%5B%7B%22recordType%22%3A%20%22person%22%7D%2C%20%7B%22hasDigitalImage%22%3A%201%7D%2C%20%7B%22text%22%3A%20%22rembrandt%22%7D%2C%20%7B%22gender%22%3A%20%7B%22id%22%3A%20%22https%3A//lux.collections.yale.edu/data/concept/6f652917-4c07-4d51-8209-fcdd4f285343%22%7D%7D%5D%7D
  JSON: {'@context': 'https://linked.art/ns/v1/search.json'...
  ```



  ```python
  from luxy import PeopleGroups

  result = (
      PeopleGroups()
      .filter(endAt={"name": "Amsterdam"})
      .get()
  )


  print("Number of results:", result.num_results)
  print("Number of pages:", result.num_pages())

  for i, page in enumerate(result.get_page_data_all(), 1):
      if i > 2: # Break after 2 pages
          break
      print(f"Page {i}:", page["id"])
      for j, item in enumerate(result.get_items(page)):
          print(f"Item {j}:", result.get_item_data(item)["_label"])
  ```



  - [x] Add support for People/Groups
      - [ ] Filter by:
          - [x] Has Digital Image
          - [x] Gender
          - [ ] Nationality (nationality)
          - [x] Person or Group Class
          - [ ] Categorized As (classification)
          - [x] Born/Formed At (startAt)
          - [ ] Born/Formed Date
          - [ ] Carried Out (carriedOut)
          - [x] Created Object (produced)
          - [x] Created Works (created)
          - [x] Curated (curated)
          - [x] Died/Dissolved At (endAt)
          - [ ] Died/Dissolved Date
          - [ ] Encountered
          - [ ] Founded By
          - [ ] Founded Group
          - [ ] Have Member
          - [ ] ID
          - [ ] Identifier
          - [x] Influenced (influenced)
          - [ ] Influenced Creation Of Objects
          - [ ] Influenced Creation Of Works
          - [ ] Member Of (memberOf)
          - [x] Occupation/Role (occupation)
          - [x] Professional Activity Categorized As (professionalActivity)
          - [x] Professionally Active At (activeAt)
          - [ ] Professionally Active Date
          - [x] Published (published)
          - [ ] Subject Of
  - [ ] Add support for Objects
  - [ ] Add support for Works
  - [ ] Add support for Places
  - [ ] Add support for Concepts
  - [ ] Add support for Events
  - [x] Add support for Pagination
  - [x] Add support for Downloading Page JSON
  - [x] Add support for Downloading Item JSON
  - [ ] Add more filters
  - [x] Add And support for filters
  - [ ] Add support for OR filters
  - [ ] Add support for have All of
  - [ ] Add support for have Any of
  - [ ] Add support for have None of
  - [ ] Add more tests
  - [ ] Add more documentation


pkgId: 6e1dc943a58ab7978507f10a2b9cf2f710368bfd7174d1abee86f54e22e534f1
name: python-lxdbapi-help
arch: noarch
version: 2.4.202412161138
epoch: 0
release: 1
summary: Development documents and examples for lxdbapi
description:
  This is the leanXcale python driver.
  Refer to leanxcale.com for information.

url: http://leanxcale.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lxdbapi-2.4.202412161138-1.src.rpm
location_href: Packages/python-lxdbapi-help-2.4.202412161138-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright <2023> <LEANXCALE S.L.>  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.  LEANXCALE FREE USE TERMS AND CONDITIONS Background  "Leanxcale" refers to Leanxcale S.L.  “You” refers to the company or organization using the Programs or that You use on its behalf.  "Program(s)" refers to Leanxcale software provided by LeanXcale according to the following terms and any updates provided by LeanXcale.  "Program Documentation" refers to Program manuals of any kind.    LICENSE RIGHTS AND RESTRICTIONS Leanxcale grants to the recipient of this Program, a nonexclusive, nontransferable, license limited to the following conditions:  Use of unmodified Programs for internal use.  Redistribution of the unmodified Programs and associated Programs Documentation without charging additional fees to Your end users for the use of the Programs.  Use of the unmodified Programs and associated Programs Documentation for training purposes.  Your license requires to comply to the following terms:  You include a copy of this license with any distribution of the Programs;  You do not remove notices from Leanxale from the Programs or Program Documentation;  You comply with all U.S. and applicable export control and economic sanctions laws and regulations that govern Your use of the Programs (including technical data);  You do not cause or permit reverse engineering, disassembly or decompilation of the Programs (except as allowed by law) by You nor allow an associated party to do so.  Any source code that may be included in the distribution with the Programs is provided solely for reference purposes and may not be modified.  OWNERSHIP Leanxcale or its licensors retain all ownership and intellectual property rights to the Programs.  INFORMATION COLLECTION The Programs' installation and/or auto-update processes, if any, may transmit a limited amount of data to Leanxcale or its service provider about those processes to help Leanxcale understand and optimize them. Leanxcale does not associate the data with personally identifiable information.    DISCLAIMER; LIMITATION OF LIABILITY 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 LEANXCALE 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 PROGRAMS OR THE USE OR OTHER DEALINGS IN THE PROGRAMS.


pkgId: 6371cef138e56704d7f3fdb2356d473d53ead509ab16e38f871f091258c54826
name: python-lyric-component-ts-transpiling-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for lyric-component-ts-transpiling
url: https://pypi.org/project/lyric-component-ts-transpiling/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lyric-component-ts-transpiling-0.1.6-1.src.rpm
location_href: Packages/python-lyric-component-ts-transpiling-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  Python wrapper for the [component-ts-transpiling](../../../components/rust/component-ts-transpiling/README.md)
  wasi library.


pkgId: fc88231954e270ea6c6d3c4f010966f449187d96f922abdabeb8510c39d27e84
name: python-lyric-js-worker-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for lyric-js-worker
url: https://pypi.org/project/lyric-js-worker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lyric-js-worker-0.1.6-1.src.rpm
location_href: Packages/python-lyric-js-worker-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  A python binding for the [lyric-js-worker](../../javascript/lyric-js-worker/README.md) library.



  ```bash
  pip install lyric-js-worker
  ```


pkgId: 1d3c2d9589c09512d5691061f662d4503dbb4f153d356455dd5152e618a31dd7
name: python-lyric-py-worker-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for lyric-py-worker
url: https://pypi.org/project/lyric-py-worker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lyric-py-worker-0.1.6-1.src.rpm
location_href: Packages/python-lyric-py-worker-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  A Python worker implementation for the lyric.

  It allows you to run your python code in a wasm environment.



  ```bash
  pip install lyric-py-worker
  ```


pkgId: f9a9b489828fcc1686534e3d848139f650d45f4c1f2d03ae016c65f8f7ae527b
name: python-lyrical-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for lyrical
description:
  A Python package to fetch song lyrics from Genius.



  ```bash
  pip install lyrical

url: https://github.com/SnarkyDeveloper/Lyrical
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lyrical-1.1.0-1.src.rpm
location_href: Packages/python-lyrical-help-1.1.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  # MIT License  Copyright (c) 2024 SnarkyDev  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: 2586a0d2250a74060fb0ffc68395ac5f803bcb19ebf5069a761bf58fd092886a
name: python-lyricsgenius-help
arch: noarch
version: 3.1.2
epoch: 0
release: 1
summary: Development documents and examples for lyricsgenius
url: https://github.com/johnwmillr/lyricsgenius
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lyricsgenius-3.1.2-1.src.rpm
location_href: Packages/python-lyricsgenius-help-3.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/johnwmillr/LyricsGenius.svg?branch=master)](https://travis-ci.org/johnwmillr/LyricsGenius)
  [![Documentation Status](https://readthedocs.org/projects/lyricsgenius/badge/?version=master)](https://lyricsgenius.readthedocs.io/en/latest/?badge=master)
  [![PyPI version](https://badge.fury.io/py/lyricsgenius.svg)](https://pypi.org/project/lyricsgenius/)
  [![Python version](https://img.shields.io/badge/python-3.x-brightgreen.svg)](https://pypi.org/project/lyricsgenius/)
  [![Donate](https://img.shields.io/badge/Support%20this%20project-grey.svg?logo=github%20sponsors)](https://github.com/sponsors/johnwmillr)

  `lyricsgenius` provides a simple interface to the song, artist, and lyrics data stored on [Genius.com](https://www.genius.com).

  The full documentation for `lyricsgenius` is available online at [Read the Docs](https://lyricsgenius.readthedocs.io/en/master/).


  Before using this package you'll need to sign up for a (free) account that authorizes access to [the Genius API](http://genius.com/api-clients). The Genius account provides a `access_token` that is required by the package. See the [Usage section](https://github.com/johnwmillr/LyricsGenius#usage) below for examples.


  `lyricsgenius` requires Python 3.

  Use `pip` to install the package from PyPI:

  ```bash
  pip install lyricsgenius
  ```

  Or, install the latest version of the package from GitHub:

  ```bash
  pip install git+https://github.com/johnwmillr/LyricsGenius.git
  ```


  Import the package and initiate Genius:

  ```python
  import lyricsgenius
  genius = lyricsgenius.Genius(token)
  ```

  If you don't pass a token to the `Genius` class, `lyricsgenus` will look for an environment variable called `GENIUS_ACCESS_TOKEN` and attempt to use that for authentication.

  ```python
  genius = Genius()
  ```

  Search for songs by a given artist:

  ```python
  artist = genius.search_artist("Andy Shauf", max_songs=3, sort="title")
  print(artist.songs)
  ```
  By default, the `search_artist()` only returns songs where the given artist is the primary artist.
  However, there may be instances where it is desirable to get all of the songs that the artist appears on.
  You can do this by setting the `include_features` argument to `True`.

  ```python
  artist = genius.search_artist("Andy Shauf", max_songs=3, sort="title", include_features=True)
  print(artist.songs)
  ```

  Search for a single song by the same artist:

  ```python
  song = artist.song("To You")


  print(song.lyrics)
  ```

  Add the song to the artist object:

  ```python
  artist.add_song(song)


  ```

  Save the artist's songs to a JSON file:

  ```python
  artist.save_lyrics()
  ```

  Searching for an album and saving it:

  ```python
  album = genius.search_album("The Party", "Andy Shauf")
  album.save_lyrics()
  ```

  There are various options configurable as parameters within the `Genius` class:

  ```python
  genius.verbose = False # Turn off status messages
  genius.remove_section_headers = True # Remove section headers (e.g. [Chorus]) from lyrics when searching
  genius.skip_non_songs = False # Include hits thought to be non-songs (e.g. track lists)
  genius.excluded_terms = ["(Remix)", "(Live)"] # Exclude songs with these words in their title
  ```

  You can also call the package from the command line:

  ```bash
  export GENIUS_ACCESS_TOKEN="my_access_token_here"
  python3 -m lyricsgenius --help
  ```

  Search for and save lyrics to a given song and album:

  ```bash
  python3 -m lyricsgenius song "Begin Again" "Andy Shauf" --save
  python3 -m lyricsgenius album "The Party" "Andy Shauf" --save
  ```

  Search for five songs by 'The Beatles' and save the lyrics:

  ```bash
  python3 -m lyricsgenius artist "The Beatles" --max-songs 5 --save
  ```



    - [Trucks and Beer: A textual analysis of popular country music](http://www.johnwmillr.com/trucks-and-beer/)
    - [Neural machine translation: Explaining the Meaning Behind Lyrics](https://github.com/tsandefer/dsi_capstone_3)
    - [What makes some blink-182 songs more popular than others?](http://jdaytn.com/posts/download-blink-182-data/)
    - [Sentiment analysis on hip-hop lyrics](https://github.com/Hugo-Nattagh/2017-Hip-Hop)
    - [Does Country Music Drink More Than Other Genres?](https://towardsdatascience.com/does-country-music-drink-more-than-other-genres-a21db901940b)
    - [49 Years of Lyrics: Why So Angry?](https://towardsdatascience.com/49-years-of-lyrics-why-so-angry-1adf0a3fa2b4)


  Please contribute! If you want to fix a bug, suggest improvements, or add new features to the project, just [open an issue](https://github.com/johnwmillr/LyricsGenius/issues) or send me a pull request.


pkgId: a3d5de09269a701192373a9b794e445f0070ddf7ffa3a6669f1e372f403b5656
name: python-lytekit-help
arch: noarch
version: 0.15.15
epoch: 0
release: 1
summary: Development documents and examples for lytekit
url: https://github.com/flyteorg/flytekit
rpm_license: apache2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lytekit-0.15.15-1.src.rpm
location_href: Packages/python-lytekit-help-0.15.15-1.noarch.rpm
checksum_type: sha256
description:
  <html>
      <p align="center">
          <img src="https://raw.githubusercontent.com/flyteorg/static-resources/main/common/flyte_circle_gradient_1_4x4.png" alt="Flyte Logo" width="100">
      </p>
      <h1 align="center">
          Flytekit Python
      </h1>
      <p align="center">
          Flytekit Python is the Python SDK built on top of Flyte
      </p>
      <h3 align="center">
          <a href="plugins/README.md">Plugins</a>
          <span> · </span>
          <a href="https://docs.flyte.org/projects/flytekit/en/latest/contributing.html">Contribution Guide</a>
      </h3>
  </html>

  [![PyPI version fury.io](https://badge.fury.io/py/flytekit.svg)](https://pypi.python.org/pypi/flytekit/)
  [![PyPI download day](https://img.shields.io/pypi/dd/flytekit.svg)](https://pypi.python.org/pypi/flytekit/)
  [![PyPI download month](https://img.shields.io/pypi/dm/flytekit.svg)](https://pypi.python.org/pypi/flytekit/)
  [![PyPI format](https://img.shields.io/pypi/format/flytekit.svg)](https://pypi.python.org/pypi/flytekit/)
  [![PyPI implementation](https://img.shields.io/pypi/implementation/flytekit.svg)](https://pypi.python.org/pypi/flytekit/)
  ![Codecov](https://img.shields.io/codecov/c/github/flyteorg/flytekit?style=plastic)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/flytekit.svg)](https://pypi.python.org/pypi/flytekit/)
  [![Docs](https://readthedocs.org/projects/flytekit/badge/?version=latest&style=plastic)](https://flytekit.rtfd.io)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Slack](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://slack.flyte.org)

  Flytekit Python is the Python Library for easily authoring, testing, deploying, and interacting with Flyte tasks, workflows, and launch plans.

  If you haven't explored Flyte yet, please refer to:
   - [Flyte homepage](https://flyte.org)
   - [Flyte core repository](https://github.com/flyteorg/flyte)



  Flytekit is the core extensible library to author Flyte workflows and tasks and interact with Flyte backend services.



  ```bash
  pip install flytekit
  ```



  ```python
  from flytekit import task, workflow

  @task(cache=True, cache_version="1", retries=3)
  def sum(x: int, y: int) -> int:
      return x + y

  @task(cache=True, cache_version="1", retries=3)
  def square(z: int) -> int:
      return z*z

  @workflow
  def my_workflow(x: int, y: int) -> int:
      return sum(x=square(z=x), y=square(z=y))
  ```


  - [Learn Flytekit by examples](https://flytecookbook.readthedocs.io/)
  - [Flytekit API documentation](https://flytekit.readthedocs.io/)



  You can find the detailed contribution guide [here](https://docs.flyte.org/projects/flytekit/en/latest/contributing.html). Plugins' contribution guide is included as well.


  Please see the [contributor's guide](https://docs.flyte.org/projects/flytekit/en/latest/contributing.html) for a quick summary of how this code is structured.


  Refer to the [issues](https://docs.flyte.org/en/latest/community/contribute.html#file-an-issue) section in the contribution guide if you'd like to file an issue.


  Refer to [plugins/README.md](plugins/README.md) for a list of available plugins.
  There may be plugins outside of this list, but the core maintainers maintain this list.


pkgId: fd8e06599f84d8c45bb7f120b1ae49dd11a32097445884c77b539a21e7b525fc
name: python-m-lib.defenc-help
arch: noarch
version: 1.1.0.post2
epoch: 0
release: 1
summary: Development documents and examples for m-lib.defenc
url: https://phdru.name/Software/Python/#m_lib
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-m-lib.defenc-1.1.0.post2-1.src.rpm
location_href: Packages/python-m-lib.defenc-help-1.1.0.post2-1.noarch.rpm
checksum_type: sha256
description:
  Get default encoding. A part of Broytman Library for Python, Copyright (C) 1996-2023 PhiloSoft Design


pkgId: 4a5ac07e97fdf630ee49f03a362aef8e11e94352a5dfea16dea9eb019b6feba8
name: python-m-tel-help
arch: noarch
version: 1.39.1
epoch: 0
release: 1
summary: Development documents and examples for m-tel
url: https://github.com/LonamiWebs/Telethon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-m-tel-1.39.1-1.src.rpm
location_href: Packages/python-m-tel-help-1.39.1-1.noarch.rpm
checksum_type: sha256
description:
    ⭐️ Thanks **everyone** who has starred the project, it means a lot!
  |logo| **Telethon** is an asyncio_ **Python 3**
  MTProto_ library to interact with Telegram_'s API
  as a user or through a bot account (bot API alternative).
      If you have code using Telethon before its 1.0 version, you must
      read `Compatibility and Convenience`_ to learn how to migrate.
      As with any third-party library for Telegram, be careful not to
      break `Telegram's ToS`_ or `Telegram can ban the account`_.


pkgId: d7d762534431880f14bc66bd3c12ca9de526241fd30cb31394fb8c840bacb45f
name: python-macode-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for macode
url: https://pypi.org/project/macode/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-macode-0.1.1-1.src.rpm
location_href: Packages/python-macode-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This repository is the official implementation of 'Masked Language Modeling Becomes Conditional Density Estimation for Tabular Data Synthesis' (`MaCoDE`) with pytorch.

  > **_NOTE:_** This repository supports [WandB](https://wandb.ai/site) MLOps platform!



  - Download and add the datasets into `data` folder to reproduce our experimental results.





  - `--bins`: the number of bins used for discretization (default: `50`)
  - `--dataset`: dataset options (`covtype`, `loan`, `kings`, `banknote`, `concrete`, `redwine`, `whitewine`, `breast`, `letter`, `abalone`)
  - `--missing_type`: how to generate missing (`None`(complete data), `MCAR`, `MAR`, `MNARL`, `MNARQ`)
  - `--missing_rate`: missingness rate (default: `0.3`)




  ```
  python main.py --imputation False --dataset <dataset> --missing_type None
  ```


  ```
  python main.py --imputation False --dataset <dataset> --missing_type <missing_type> --missing_rate <missing_rate>
  ```


  ```
  python main.py --imputation True --dataset <dataset> --missing_type <missing_type> --missing_rate <missing_rate>
  ```




  ```
  python inference.py --imputation False --dataset <dataset> --missing_type None
  ```


  ```
  python inference.py --imputation False --dataset <dataset> --missing_type <missing_type> --missing_rate <missing_rate>
  ```
  - for privacy control experiment (`--tau`: user defined temperature for privacy controlling (default: `1.0`))
  ```
  python inference.py --imputation False --dataset <dataset> --missing_type <missing_type> --missing_rate <missing_rate> --tau <tau>
  ```


  ```
  python imputer.py --imputation True --dataset <dataset> --missing_type <missing_type> --missing_rate <missing_rate>
  ```



  ```
  .
  +-- data
  +-- assets
  +-- datasets
  |       +-- imputation.py
  |       +-- preprocess.py
  |       +-- raw_data.py
  +-- modules
  |       +-- evaluation_imputation.py
  |       +-- evaluation.py
  |       +-- metric_MLu.py
  |       +-- metric_privacy.py
  |       +-- metric_stat.py
  |       +-- missing.py
  |       +-- model.py
  |       +-- train_missing.py
  |       +-- train.py
  |       +-- utility.py
  +-- main.py
  +-- inference.py
  +-- imputer.py
  +-- LICENSE
  +-- README.md
  ```


  ```

  ```


pkgId: ab98bb46a0682740686594edc9802b16095d1cce335832d33968cc4ffd009457
name: python-macrobond-data-api-help
arch: noarch
version: 3.0.1
epoch: 0
release: 1
summary: Development documents and examples for macrobond-data-api
url: https://github.com/macrobond/macrobond-data-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-macrobond-data-api-3.0.1-1.src.rpm
location_href: Packages/python-macrobond-data-api-help-3.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable -->
  <div align="center">
      <a href="https://www.macrobond.com/">
          <img loading="lazy" aria-roledescription="brand logo" alt="Macrobond logo" src="https://macrobond.github.io/macrobond-data-api/assets/Macrobond_logo_Color.svg" width="30%">
      </a>
  </div>

  <h1 align="center">Macrobond Data API for Python</h1>

  <p align="center">
      <a href="https://pypi.org/project/macrobond-data-api/">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/macrobond-data-api">
      </a>
      <a href="https://pypi.org/project/macrobond-data-api/">
          <img alt="PyPI" src="https://img.shields.io/pypi/pyversions/macrobond-data-api.svg">
      </a>
      <a href="https://github.com/macrobond/macrobond-data-api/blob/main/LICENSE">
          <img alt="License: MIT" src="https://black.readthedocs.io/en/stable/_static/license.svg">
      </a>
      <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg">
      </a>
      <a href="https://github.com/macrobond/macrobond-data-api/actions/workflows/ci.yml">
          <img alt="Continuous Integration" src="https://github.com/macrobond/macrobond-data-api/actions/workflows/ci.yml/badge.svg">
      </a>
      <!--
      <a href="https://github.com/macrobond/macrobond-data-api/actions/workflows/deploying-github-pages.yaml">
          <img alt="Deploy to Github Pages" src="https://github.com/macrobond/macrobond-data-api/actions/workflows/deploying-github-pages.yaml/badge.svg">
      </a>
      <a href="https://github.com/macrobond/macrobond-data-api/actions/workflows/deploying-github-pages.yaml">
          <img alt="Deploy to PyPI" src="https://github.com/macrobond/macrobond-data-api/actions/workflows/python-publish.yml/badge.svg">
      </a>
      -->
  </p>
  <!-- markdownlint-enable -->

  The Macrobond Data API for Python is used to access the world’s most extensive
  macroeconomic, aggregate financial and sector database provided by [Macrobond](http://www.macrobond.com).
  Exposes a common API in Python for the
  [Macrobond Web](https://help.macrobond.com/technical-information/the-macrobond-data-web-api-feed/)
  and [Client data](https://help.macrobond.com/technical-information/the-macrobond-api-for-python/)
  APIs

  You have to be a licensed user and have a Data+ or data feed user account in
  order to use the API.

  [***Examples in Jupyter Notebooks*** to help you get started](https://github.com/macrobond/macrobond-api-examples)

  [***API reference***](https://macrobond.github.io/macrobond-data-api/)



  ```python
  import macrobond_data_api as mb_api

  usgdp = mb_api.get_one_series("usgdp")
  ```



  ```python

  from macrobond_data_api.web import WebClient

  with WebClient('client id', 'client secret') as api:
      series = api.get_one_series('usgdp')


  from macrobond_data_api.com import ComClient

  with ComClient() as api:
      series = api.get_one_series('usgdp')
  ```



  The Macrobond Data API for Python uses either the
  [Macrobond Web REST API](https://help.macrobond.com/technical-information/the-macrobond-data-web-api-feed/)
  or the [Macrobond Client data API](https://help.macrobond.com/technical-information/the-macrobond-api-for-python/)
  to obtain time series with values and metadata.
  The API consists of a set of functions in common between the underlying APIs as
  well as specialized functions unique to each implementation.



  Macrobond Data API for Python is available on [PyPI](https://pypi.org/project/macrobond-data-api/):

  ```console
  python -m pip install macrobond-data-api
  ```

  Macrobond Data API for Python officially supports Python 3.9+.



  > [!NOTE]
  > If u are using a proxy see "Using of system keyring for http proxy" first.

  When using WebClient it is recommended to use the system keyring to store the API credentials.
  This can be done easily by running the include script using this command:

  ```console
  python -c "from macrobond_data_api.util import *; save_credentials_to_keyring()"
  ```



  For users operating behind an HTTP proxy, it is advisable to utilize the system keyring to store proxy settings and
  credentials.
  This can be conveniently accomplished by executing the included script with the following command:

  ```console
  python -c "from macrobond_data_api.util import *; save_proxy_to_keyring()"
  ```



  * macOS [Keychain](https://en.wikipedia.org/wiki/Keychain_%28software%29)
  * Freedesktop [Secret Service](http://standards.freedesktop.org/secret-service/)
  supports many DE including GNOME (requires [secretstorage](https://pypi.python.org/pypi/secretstorage))
  * KDE4 & KDE5 [KWallet](https://en.wikipedia.org/wiki/KWallet) (requires [dbus](https://pypi.python.org/pypi/dbus-python))
  * [Windows Credential Locker](https://docs.microsoft.com/en-us/windows/uwp/security/credential-locker)



  We welcome community pull requests for bug fixes, enhancements, and documentation.



  [Support options](https://help.macrobond.com/support/)


pkgId: f7a10349f1ca721a4bb3221f54eef5d8f640ec06f7ad06ad1be2b5413cbd94ff
name: python-madcubapy-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for madcubapy
description:
  Install from PyPI with:
  pip install madcubapy

url: https://github.com/dhaasler/madcubapy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-madcubapy-0.1.0-1.src.rpm
location_href: Packages/python-madcubapy-help-0.1.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 dhaasler  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: b6ad2ba4ec342a133cd86927833967042b9014f155a16601b5ee381c59f4a780
name: python-mag-tools-help
arch: noarch
version: 0.1.36
epoch: 0
release: 1
summary: Development documents and examples for mag-tools
url: http://gitlab.magnetitech.com:8088/sources/frame/py-frame/mag_tools.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mag-tools-0.1.36-1.src.rpm
location_href: Packages/python-mag-tools-help-0.1.36-1.noarch.rpm
checksum_type: sha256
description:
  - Rust编译器
      访问 Rust 官网 并下载适用于 Windows 的安装程序，或者直接运行以下命令：
      ```Bash
          Invoke-WebRequest -Uri https://sh.rustup.rs -OutFile rustup-init.exe
      ```
      ```Bash
          .\rustup-init.exe
      ```
     添加 Rust 编译器的路径（通常是 C:\Users\你的用户名\.cargo\bin）
  - 安装依赖项
    ```Bash
      pip install --upgrade pip
      pip install maturin
    ```

  - 创建虚拟环境
      ```Bash
      python -m venv venv
  - 激活虚拟环境
      ```Bash
      venv\Scripts\activate
      ```
  - 安装依赖项
      ```Bash
        pip install -r requirements.txt
      ```
  - 编辑打包
      ```Bash
        python setup.py sdist bdist_wheel
      ```
  - 本地安装库
      ```Bash
         pip install dist/mag_tools-0.1.x-py3-none-any.whl
      ```
    - 上传包
      ```Bash
        twine upload dist/*
      ```

  - 获取API Token
  - 配置.pypirc 文件： 在用户主目录下创建 .pypirc 文件，并添加以下内容(请用真实的token替代)
    ```Plaintext
    [distutils]
    index-servers =
        pypi

    [pypi]
    username = __token__
    password = pypi-AgENdGVzdC5weXBpLm9yZwIkZjM2YzQ2Y2QtY2Y2OS00YjY3LWE4YzUtY2Y2OTY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3Yj
    ```


pkgId: 35cea2da51b644abd223ba54e7f4413c32b304b60e75b56472190ecda211d97e
name: python-mag-tools-help
arch: noarch
version: 0.1.57
epoch: 0
release: 1
summary: Development documents and examples for mag-tools
url: http://gitlab.magnetitech.com:8088/sources/frame/py-frame/mag_tools.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mag-tools-0.1.57-1.src.rpm
location_href: Packages/python-mag-tools-help-0.1.57-1.noarch.rpm
checksum_type: sha256
description:
  - Rust编译器
      访问 Rust 官网 并下载适用于 Windows 的安装程序，或者直接运行以下命令：
      ```Bash
          Invoke-WebRequest -Uri https://sh.rustup.rs -OutFile rustup-init.exe
      ```
      ```Bash
          .\rustup-init.exe
      ```
     添加 Rust 编译器的路径（通常是 C:\Users\你的用户名\.cargo\bin）
  - 安装依赖项
    ```Bash
      pip install --upgrade pip
      pip install maturin
    ```
  - 安装 twine
    ```Bash
      which python
      which python3
      open /Applications/Python\ 3.x/Install\ Certificates.command
      pip install twine
    ```
      其中 3.x为python版本号

  - 创建虚拟环境
      ```Bash
      python -m venv venv
  - 激活虚拟环境
      ```Bash
      venv\Scripts\activate
      ```
  - 安装依赖项
      ```Bash
        pip install -r requirements.txt
      ```
  - 编辑打包
      ```Bash
        python setup.py sdist bdist_wheel
      ```
  - 本地安装库
      ```Bash
         pip install dist/mag_tools-0.1.x-py3-none-any.whl
      ```
    - 上传包
      ```Bash
        twine upload dist/*
      ```

  - 获取API Token
  - 配置.pypirc 文件： 在用户主目录下创建 .pypirc 文件，并添加以下内容(请用真实的token替代)
    ```Plaintext
    [distutils]
    index-servers =
        pypi

    [pypi]
    username = __token__
    password = pypi-AgENdGVzdC5weXBpLm9yZwIkZjM2YzQ2Y2QtY2Y2OS00YjY3LWE4YzUtY2Y2OTY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3YjY3Yj
    ```


pkgId: c003b419ff5f29fc0deeddd15929b2ed63c651aeaf1bad4c45e1f87dac6bbde2
name: python-magent-ui-help
arch: noarch
version: 0.1.17
epoch: 0
release: 1
summary: Development documents and examples for magent-ui
url: https://pypi.org/project/magent-ui/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magent-ui-0.1.17-1.src.rpm
location_href: Packages/python-magent-ui-help-0.1.17-1.noarch.rpm
checksum_type: sha256
description:
  与 [agentUniverse](https://github.com/alipay/agentUniverse) 联合推出本地研发产品化方案，详见[产品化文档](https://github.com/alipay/agentUniverse/blob/master/docs/guidebook/zh/10_1_1_%E4%BA%A7%E5%93%81%E5%8C%96%E5%B9%B3%E5%8F%B0%E5%BF%AB%E9%80%9F%E5%BC%80%E5%A7%8B.md)

  PEER 多智能体对话
  ![PEER 多智能体对话](../../docs/assets/au-peer-chat.jpg)

  reAct 智能体开发
  ![reAct 智能体开发](../../docs/assets/au-react-dev.jpg)



  支持 uvicorn 配置

  ```python
  from magent_ui import launch
  launch(host='0.0.0.0', port=8888, root_path='/')
  ```



  - 用户级配置： ~/.magent/ui_config.py
  - 项目级配置： {project_root}/.magent_ui_config.py
  - 项目级配置： {project_root}/config/magent_ui_config.py



  MAGENT_UI_SERVER_XX


pkgId: dfddc17299bfdf9e5d045edc5f4ab1995a13eeb8f7f70d8fa756215b07aa9ebb
name: python-magi-cli-pypi-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for magi-cli-pypi
url: https://github.com/bobbyhiddn/Magi_CLI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magi-cli-pypi-1.0.2-1.src.rpm
location_href: Packages/python-magi-cli-pypi-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  ![banner](MAGI_Keys.png)

  > "Any sufficiently advanced technology is indistinguishable from magic."
  > *― Arthur C. Clarke*

  Embrace the arcane with Magi CLI, a spellcasting-inspired command line interface (CLI) tool that fuses the mystical arts with practical utility. Unravel the secrets of the cosmos and command your operating system with the wisdom of the ancient magi.



  Magi CLI is forged in Python, channeling the enigmatic power of the Click library. It offers an array of spells (commands) that manipulate the filesystem, manage files, and automate tasks. Designed to be extendable, Magi CLI allows you to add new spells as your knowledge of the hidden arts expands. While platform agnostic, it performs best with a bash terminal like Git Bash.




  Your magical workspace contains:
  - `.tome/`: Storage for spell bundles
  - `.orb/`: Local spell cache
  - `.graveyard/`: Temporary storage for deleted files
  - `.runes/`: GUI elements for spell execution


  The root command serving as the universal execution command. It displays all available spells and `.spell` files in your tome when run without arguments. Currently supports:
  - Python scripts (.py)
  - Shell scripts (.sh)
  - Spell bundles (.spell)



  - **Effectiveness**: Spells must work reliably. Half-functioning spells won't be included in release versions.
  - **Flavorfulness**: Spells should feel magical, requiring only essential memorization unless additional features can be added in a thematic way.
  - **Modularity**: Each spell must work both as `cast spell target` and as a standalone script (`python path/to/spell.py target`).
  - **Innovation**: Spells should not duplicate standard UNIX commands. We're crafting new magic, not recreating existing tools.
  - **Fun**: Keep the magical essence alive with thematic messages and interactions!




  - **Fireball** (`fb`): Transmute a file or directory into ashes, sending it to the '.graveyard' realm
  - **Banish** (`bn`): Move files to a temporary exile realm
  - **Divine** (`dv`): Display detailed file/directory information


  - **Necromancy** (`nc`): Initialize the .graveyard for file preservation
  - **Raise_Dead** (`rd`): Restore files from the .graveyard


  - **Spellcraft** (`sc`): Create new spells and spell bundles
  - **Ponder** (`pd`): Explore and manage available spells. Connect to the Chamber for additional community spells.

  Additional spells are available through the Magi Chamber (`magi-chamber.fly.dev`), accessible via the `ponder` spell.



  Spellcraft (`sc`) is a powerful tool for creating new spells. It supports three main types of spell creation:


  Create spells that combine multiple commands:
  ```bash

  cast sc 3 backup_spell
  ```
  The wizard will prompt you for:
  - Spell description
  - Three commands to be executed in sequence


  Convert existing Python or Shell scripts into spells:
  ```bash

  cast sc path/to/script.py spell_name


  cast sc path/to/script.sh spell_name
  ```


  Create complex spells with multiple files and resources using YAML configuration:

  ```yaml

  name: my_spell
  description: A powerful new spell
  type: bundled
  shell_type: python
  entry_point: spell/main.py
  dependencies:
    python:
      - requests>=2.0.0

  code: |
    import click

    @click.command()
    def main():
        """Your spell's magic here."""
        click.echo("Spell cast successfully!")

  artifacts:
    - path: data/config.json
      content: |
        {
          "settings": "value"
        }
  ```

  Create the bundled spell:
  ```bash
  cast sc spell.yaml
  ```




  ```bash
  pip install magi-cli-pypi
  ```


  ```bash
  git clone https://github.com/bobbyhiddn/Magi_CLI.git
  cd Magi_CLI
  pip install .
  ```



  ```mermaid
  stateDiagram-v2
      state "cast" as entry

      state "Command Handling" as commands {
          SpellParser
          CommandRegistry
      }

      state "Executable Types" as types {
          state ".py files" as py
          state ".sh files" as sh
          state ".spell bundles" as bundle
      }

      state "Spellcraft System" as craft {
          state "SpellBundle" as sb {
              LoadConfig
              CreateBundle
          }

          state "Sigildry" as sig {
              GenerateHash
              GenerateSVG
              VerifySigil
          }
      }

      state "~/.sanctum" as sanctum {
          .tome
          .orb
          .graveyard
      }

      entry --> commands
      commands --> types
      bundle --> craft
      craft --> sanctum
      types --> sanctum
  ```


  - Spells are verified using sigils (cryptographic signatures)
  - Dependencies are installed in isolated environments
  - Spell bundles are checked for integrity before execution


  See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.


  MIT License


  Created and maintained by Micah Longmire (@bobbyhiddn)


pkgId: 4f94bfea57395f2c0ec6f8cd5ba8d33f06727f4ced91cf45355c7f114e741f2f
name: python-magic-dash-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for magic-dash
url: https://github.com/CNFeffery/magic-dash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magic-dash-0.2.1-1.src.rpm
location_href: Packages/python-magic-dash-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  	<img src="./magic_dash/templates/magic-dash/assets/imgs/logo.svg" height=100></img>
  </p>
  <h1 align="center">magic-dash</h1>
  <div align="center">

  [![Pyhton](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)](./setup.py)
  [![GitHub](https://shields.io/badge/license-MIT-informational)](https://github.com/CNFeffery/magic-dash/blob/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/magic-dash.svg?color=dark-green)](https://pypi.org/project/magic-dash/)
  [![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)

  </div>

  命令行工具，用于快捷生成一系列标准[Dash](https://github.com/plotly/dash)应用工程模板。



  [安装](#install)<br>
  [使用](#usage)<br>
  [内置模板列表](#template-list)<br>

  <a name="install" ></a>



  ```bash
  pip install magic-dash -U
  ```

  <a name="usage" ></a>





  ```bash
  magic-dash list
  ```



  - 默认生成到当前路径

  ```bash
  magic-dash create --name magic-dash
  ```

  - 指定生成路径

  ```bash
  magic-dash create --name magic-dash --path 目标路径
  ```



  ```bash
  magic-dash --version
  ```



  ```bash
  magic-dash --help

  magic-dash list --help

  magic-dash create --help
  ```

  <a name="template-list" ></a>



  ```bash
  内置Dash应用项目模板：

  - magic-dash    基础多页面应用模板
  - magic-dash-pro    多页面+用户登录应用模板
  - simple-tool    单页面工具应用模板
  ```


pkgId: b87285cf95e08484937f54fa2e7ba800a8abe97fd919c5f7b649b3a9731fe9d5
name: python-magic-hour-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for magic-hour
url: https://pypi.org/project/magic-hour/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magic-hour-0.7.1-1.src.rpm
location_href: Packages/python-magic-hour-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  Magic Hour provides an API (beta) that can be integrated into your own application to generate videos using AI.

  Webhook documentation can be found [here](https://magichour.ai/docs/webhook).

  If you have any questions, please reach out to us via [discord](https://discord.gg/JX5rgsZaJp).



  Every request requires an API key.

  To get started, first generate your API key [here](https://magichour.ai/settings/developer).

  Then, add the `Authorization` header to the request.

  | Key | Value |
  |-|-|
  | Authorization | Bearer mhk_live_apikey |

  > **Warning**: any API call that renders a video will utilize frames in your account.




  ```python
  from magic_hour import Client
  from os import getenv

  client = Client(token=getenv("API_TOKEN"))
  ```



  ```python
  from magic_hour import AsyncClient
  from os import getenv

  client = AsyncClient(token=getenv("API_TOKEN"))
  ```





  * [create](magic_hour/resources/v1/ai_headshot_generator/README.md#create) - Create AI Headshots



  * [create](magic_hour/resources/v1/ai_image_generator/README.md#create) - Create AI Images



  * [create](magic_hour/resources/v1/ai_image_upscaler/README.md#create) - Create Upscaled Image



  * [create](magic_hour/resources/v1/ai_photo_editor/README.md#create) - AI Photo Editor



  * [create](magic_hour/resources/v1/ai_qr_code_generator/README.md#create) - Create AI QR Code



  * [create](magic_hour/resources/v1/animation/README.md#create) - Create Animation



  * [create](magic_hour/resources/v1/face_swap/README.md#create) - Create Face Swap video



  * [create](magic_hour/resources/v1/face_swap_photo/README.md#create) - Create Face Swap Photo



  * [create](magic_hour/resources/v1/files/upload_urls/README.md#create) - Generate asset upload urls



  * [create](magic_hour/resources/v1/image_background_remover/README.md#create) - Image Background Remover



  * [delete](magic_hour/resources/v1/image_projects/README.md#delete) - Delete image
  * [get](magic_hour/resources/v1/image_projects/README.md#get) - Get image details



  * [create](magic_hour/resources/v1/image_to_video/README.md#create) - Create Image-to-Video



  * [create](magic_hour/resources/v1/lip_sync/README.md#create) - Create Lip Sync video



  * [create](magic_hour/resources/v1/text_to_video/README.md#create) - Create Text-to-Video



  * [delete](magic_hour/resources/v1/video_projects/README.md#delete) - Delete video
  * [get](magic_hour/resources/v1/video_projects/README.md#get) - Get video details



  * [create](magic_hour/resources/v1/video_to_video/README.md#create) - Create Video-to-Video

  <!-- MODULE DOCS END -->


pkgId: af21518d8c60418e377b28c746ee51d66b57a0ad1933e994c80267c35edbd7c9
name: python-magic-lantern-help
arch: noarch
version: 0.0.19
epoch: 0
release: 1
summary: Development documents and examples for magic-lantern
url: https://github.com/normanlorrain/magic-lantern
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magic-lantern-0.0.19-1.src.rpm
location_href: Packages/python-magic-lantern-help-0.0.19-1.noarch.rpm
checksum_type: sha256
description:
  A presentation tool for kiosks, digital signage, slide shows.

  Supports *png* and *jpg*.  *PDF* files are also supported; each page is internally converted to an image file.

  You can specify a single directory/folder for the images, or organise them into folders and provide a configuration file to control the sequence of images. This sequence is called the "*slide show*".







  [pipx](https://pipx.pypa.io/stable/), via [Scoop](https://scoop.sh/)

  ```
  scoop install pipx
  pipx ensurepath
  pipx install magic-lantern
  ```



  ```bash
  pipx install magic-lantern
  ```



  See

  ```bash
  magic-lantern --help
  ```

  When running, use the following keys to control the slideshow:
  - **space bar**: play / pause
  - **q**: quit
  - **p**, **left arrow**: previous image
  - **n**, **right arrow**: previous image
  - **y**, display of year (on/off)



  To reload the configuration and slide show:
  ```bash
  pkill -USR1 magic-lantern
  ```

  This is useful if you have the app running automatically (e.g. Gnome autostart) and have updated the slide show.


  You can provide a simple path to a collection of images...

  ```
  magic-lantern /usr/share/backgrounds
  ```

  ... or you can supply a configuration file:
  ```
  magic-lantern -c ~/slideshow/example.toml
  ```
  See [example.toml](docs/example.toml).

  The configuration file can specify multiple ***albums*** to include in the slideshow.  The behaviour of each album can be unique.  The file contains two sections:

  - The first part of the file contains any default/global values.  They apply to all the subsequent albums if not overridden.  These are optional but are included in the example.

  - The remainder of the file defines the albums.  Each album points to a directory containing images to include in the slide show.  Images are added automatically. Images can be separated into different albums depending on their intended behaviour.
  Options given here override the defaults provided previously.



  This is a list of keys, their scope, etc., defined in the configuration file:


  - *scope*: global
  - *type*: list of strings
  - *value*: list the folders to exclude from the image search
  - *default*: empty list.  All png/jpg/pdf files will be included.


  - *scope*: global
  - *type*: bool
  - *value*: turn on full-screen mode
  - *default*: false


  - *scope*: global and album
  - *type*: integer
  - *value*: give the weight to an album when choosing them randomly. When the slide show is generated, each image is taken from each album, chosen [randomly](https://docs.python.org/3/library/random.html#random.choices), according the the given weights.

  - *default*: 1


  - *scope*: global and album
  - *type*: integer
  - *value*: give the time in seconds after a slide before the next one.
  - *default*: 5


  In TOML this specifies an array of key/value pairs.  Each of these entries define each album being configured.


  - *scope*: album
  - *type*: string
  - *value*: points to the path of the directory containing the album.  Can be an absolute path, or relative to the configuration file.


  - *scope*: album
  - *type*: one of
      - `"sequence"`: photos in this album are picked in sequence
      - `"random"`: photos in this album are picked randomly
      - `"atomic"`: photos in this album are picked in sequence, and grouped together.  Once each image has been displayed, the slide show resumes with the next.
  - *value*: defines the behaviour of the slideshow for each album.
  - *default*: `"sequence"`


pkgId: 57946754ea8b8b783f02cb7f30f88dddb8cacf37c28ad5960436e568a31332ae
name: python-magic-maths-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for magic-maths
url: https://pypi.org/project/magic-maths/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magic-maths-0.1.0-1.src.rpm
location_href: Packages/python-magic-maths-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Magically import evaluated math expressions. Like so:

  ```py
  from magic_math import TEN_TIMES_FIVE_DIVIDED_BY_TWO
  from magic_math import FIVE_TIMES_FIVE
  from magic_math import TWO_HUNDRED_MINUS_TEN
  from magic_math import SIX_HUNDRED_AND_SIXTY_SIX_DIVIDED_BY_TWO_TIMES_EIGHT
  from magic_math import OPEN_FIVE_MINUS_THREE_CLOSE_TIMES_TEN

  ABC=7
  from magic_math import OPEN_TEN_MINUS_OPEN_ABC_DIVIDED_BY_TWO_CLOSE_CLOSE

  print(f"{TEN_TIMES_FIVE_DIVIDED_BY_TWO = }")  # 25.0
  print(f"{FIVE_TIMES_FIVE = }")  # 25.0
  print(f"{TWO_HUNDRED_MINUS_TEN = }")  # 190.0
  print(f"{SIX_HUNDRED_AND_SIXTY_SIX_DIVIDED_BY_TWO_TIMES_EIGHT = }")  # 2664.0
  print(f"{OPEN_FIVE_MINUS_THREE_CLOSE_TIMES_TEN = }")  # 20.0
  print(f"{OPEN_TEN_MINUS_OPEN_ABC_DIVIDED_BY_TWO_CLOSE_CLOSE = }")  # 6.5
  ```

  Notes:

  - All returned values are in floating point form
  - Floats can be specified using "point" or "dot"
  - Variables are partially supported, currently only within scripts
  - Uses basic postfix order of precendence
  - Basic parenteses syntax using `OPEN` and `CLOSE` values

  Credits:

  - Inspired by and uses code from David Buchanan's [`magic-numbers` package](https://github.com/DavidBuchanan314/magic-numbers)


pkgId: 40fc814335a133d897b5f81bffc67d80434d7d49284afbaa7f690a006cda4340
name: python-magic-numbers-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for magic-numbers
url: https://pypi.org/project/magic-numbers/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magic-numbers-1.0.3-1.src.rpm
location_href: Packages/python-magic-numbers-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Magically import magic number constants. Like so:

  ```py
  from magic_numbers import FORTY_TWO, SIXTY_NINE, FOUR_HUNDRED_AND_TWENTY
  from magic_numbers import ONE_THOUSAND_THREE_HUNDRED_AND_TWELVE
  from magic_numbers import THREE_POINT_ONE_FOUR_ONE_FIVE_NINE_TWO as PI

  print(f"{FORTY_TWO = }")  # 42
  print(f"{SIXTY_NINE = }")  # 69
  print(f"{FOUR_HUNDRED_AND_TWENTY = }")  # 420
  print(f"{ONE_THOUSAND_THREE_HUNDRED_AND_TWELVE = }")  # 1312
  print(f"{PI = }")  # 3.141592
  ```

  Note: Floats can only be specified using "point", there is no support (yet) for fractions like `THREE_AND_A_HALF` or `TWO_THIRDS`



  ```sh
  python3 -m pip install magic-numbers
  ```


pkgId: da2e85f222951e1282daf9f9bd379b8e5f4ce30dfbaa2cecda58d0fc611c23df
name: python-magicgui-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for magicgui
url: https://pypi.org/project/magicgui/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magicgui-0.10.0-1.src.rpm
location_href: Packages/python-magicgui-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <img src="https://raw.githubusercontent.com/pyapp-kit/magicgui/main/resources/logo_long.png" alt="magicgui" />
  </h1>

  <p align="center">
    <a href="https://github.com/pyapp-kit/magicgui/blob/main/LICENSE">
      <img src="https://img.shields.io/github/license/pyapp-kit/magicgui" alt="magicgui is released under the MIT license." />
    </a>
    <a href="https://pypi.python.org/pypi/magicgui">
      <img src="https://img.shields.io/pypi/v/magicgui.svg" alt="magicgui on PyPI" />
    </a>
    <a href="https://anaconda.org/conda-forge/magicgui">
      <img src="https://img.shields.io/conda/vn/conda-forge/magicgui" alt="magicgui on conda-forge" />
    </a>
    <a href="https://python.org">
      <img src="https://img.shields.io/pypi/pyversions/magicgui.svg?color=green" alt="magicgui python version support" />
    </a>
    </p>
    <p align="center">
    <a href="https://github.com/pyapp-kit/magicgui/actions/workflows/test_and_deploy.yml">
      <img src="https://github.com/pyapp-kit/magicgui/actions/workflows/test_and_deploy.yml/badge.svg" alt="magicgui build status" />
    </a>
    <a href="https://codecov.io/gh/pyapp-kit/magicgui">
      <img src="https://codecov.io/gh/pyapp-kit/magicgui/branch/main/graph/badge.svg" alt="magicgui code coverage" />
    </a>
    <a href="https://zenodo.org/badge/latestdoi/238805437">
      <img src="https://zenodo.org/badge/238805437.svg" alt="cite magicgui" />
    </a>
  </p>

  <p align="center">
   <em>build GUIs from type annotations, using magic.</em>
  </p>




  [https://pyapp-kit.github.io/magicgui/](https://pyapp-kit.github.io/magicgui/)



  `magicgui` uses `qtpy` to support both `pyside2` and `pyqt5` backends.  However, you
  must have one of those installed for magicgui to work.

  install with pip

  ```bash
  pip install magicgui[pyqt5]

  pip install magicgui[pyside2]
  ```

  or with conda:

  ```bash
  conda install -c conda-forge magicgui pyqt  # or pyside2 instead of pyqt
  ```

  > :information_source: If you'd like to help us extend support to a different backend,
  > please open an [issue](https://github.com/pyapp-kit/magicgui/issues).



  ```python
  from magicgui import magicgui
  from enum import Enum

  class Medium(Enum):
      Glass = 1.520
      Oil = 1.515
      Water = 1.333
      Air = 1.0003


  @magicgui(call_button="calculate", result_widget=True)
  def snells_law(aoi=30.0, n1=Medium.Glass, n2=Medium.Water, degrees=True):
      import math

      aoi = math.radians(aoi) if degrees else aoi
      try:
          result = math.asin(n1.value * math.sin(aoi) / n2.value)
          return math.degrees(result) if degrees else result
      except ValueError:
          return "Total internal reflection!"


  snells_law.show(run=True)
  ```

  ![snells](https://raw.githubusercontent.com/pyapp-kit/magicgui/main/resources/snells.png)

  But that's just the beginning!  Please see [Documentation](https://pyapp-kit.github.io/magicgui/) for many more details
  and usage examples.



  Contributions are welcome!

  See contributing guide [here](https://github.com/pyapp-kit/magicgui/blob/main/docs/CONTRIBUTING.md).


pkgId: 3339a6f367fadbbdcec1ab0cbae94f171dcbe3661a93271b2a66a642296a83d0
name: python-maidr-help
arch: noarch
version: 0.10.5
epoch: 0
release: 1
summary: Development documents and examples for maidr
url: https://pypi.org/project/maidr/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maidr-0.10.5-1.src.rpm
location_href: Packages/python-maidr-help-0.10.5-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="https://github.com/xability/maidr/blob/main/logo/logo.svg" width="350px" alt="A stylized MAIDR logo, with curved characters for M A, a hand pointing for an I, the D character, and R represented in braille."/>

  <hr style="color:transparent" />
  <br />
  </div>



  Python binder for maidr library



  ```sh

  pip install -U maidr
  ```

  ```sh

  pip install -U git+https://github.com/xability/py-maidr.git
  ```



  Please visit the [user guide](https://xability.github.io/py-maidr/) page.




  We provide [some example code](https://github.com/xability/py-maidr/blob/main/example) for using py-maidr with matplotlib, seaborn, Jupyter Notebook, Quarto, Shiny, and Streamlit.


pkgId: 94d057f495b866fcfc5d1cdee49fefe13c1be135cb0050f7dac3002ee8f178e8
name: python-maihem-help
arch: noarch
version: 1.7.0
epoch: 0
release: 1
summary: Development documents and examples for maihem
url: https://github.com/maihemlabs/maihem
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maihem-1.7.0-1.src.rpm
location_href: Packages/python-maihem-help-1.7.0-1.noarch.rpm
checksum_type: sha256
description:
  The **maihem** python package creates AI agents that automatically test your conversational LLM applications.

  - Automatically find failures in your LLM applications before your users do
  - Build LLM applications that you and others can trust with our Quality Assurance Reports

  To install the API, run the following command:
  ```
  pip install maihem
  ```

  Check out our [documentation](https://docs.maihem.ai/quickstart) to learn how to use **maihem**.

rpm_license:
  MIT License  Copyright (c) 2024 MAIHEM  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: 913fa9aa72d27baa75ab364170aa2177c3c063179b30c32130186afbf12d02a8
name: python-mailstream-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for mailstream
url: https://github.com/christianobora/mailstream
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mailstream-0.1.4-1.src.rpm
location_href: Packages/python-mailstream-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  MailStream is an asynchronous IMAP email client built with `aioimaplib`. It supports streaming emails, polling for updates, and broadcasting new emails to listeners.



  - Asynchronous IMAP connection
  - Fetch unseen emails
  - Broadcast new emails to subscribers
  - Easily integrate with context management



  ```bash
  pip install mailstream
  ```



  ```python
  import asyncio
  from mailstream import MailStreamClient, Config

  async def process_email(mail):
      print(f"New email from: {mail.from_email}")
      print(f"Subject: {mail.subject}")

  config = Config(
      host="imap.example.com",
      port=993,
      email="your_email@example.com",
      password="your_password",
      debug=True
  )

  async def main():
      client = MailStreamClient(config)
      await client.connect()

      
      listener = client.subscribe()

      
      while True:
          mail = await listener.get()
          await process_email(mail)

      
      await client.close()

  asyncio.run(main())
  ```



  - `host`: IMAP server hostname (required)
  - `email`: Login email (required)
  - `password`: Login password (required)
  - `port`: IMAP server port (default: 993)
  - `mailbox`: Target mailbox (default: 'INBOX')
  - `debug`: Enable debug mode (default: False)





  ```python

  unseen_mails = client.get_unseen_mails()
  for mail in unseen_mails:
      print(mail.subject)
  ```



  ```python
  async def listener1(mail):
      print("Listener 1 received:", mail.subject)

  async def listener2(mail):
      print("Listener 2 received:", mail.subject)

  listener1_queue = client.subscribe()
  listener2_queue = client.subscribe()
  ```



  ```python
  await client.wait_for_updates(poll_interval=10.0)
  ```


  For more examples, including advanced usage, please see the [examples](examples) directory.



  ```python
  from mailstream import ConnectionError, AuthenticationError

  try:
      client = MailStreamClient(
          host='imap.example.com',
          port=993,
          email='your_email@example.com',
          password='your_password',
          debug=True
      )
      await client.connect()
  except (ConnectionError, AuthenticationError) as e:
      print(f"Connection failed: {e}")
  ```



  Contributions are welcome! Please see our [contributing guidelines](docs/development.md) for more details.



  [MIT](LICENSE)



  For issues, please open a GitHub issue in the repository.


pkgId: bc1240b362854c2a7eaae94a2ccf4a95a362b23896cbbe412044e6e213f0c0d2
name: python-maimai-py-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for maimai-py
url: https://pypi.org/project/maimai-py/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maimai-py-0.2.0-1.src.rpm
location_href: Packages/python-maimai-py-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/maimai-py)](https://pypi.org/project/maimai-py/)
  ![License](https://img.shields.io/pypi/l/maimai-py)
  ![Python versions](https://img.shields.io/pypi/pyversions/maimai-py)
  [![zh](https://img.shields.io/badge/README-中文-green.svg)](https://github.com/TrueRou/maimai.py/blob/main/README_CN.md)


  The definitive python wrapper for MaimaiCN related development, wrapping the frequently used methods from DivingFish and LXNS.

  We provide data models and methods based on MaiMai standard, and make implementation for both DivingFish and LXNS.

  Support querying songs, player information, scores, ratings, name plates from any data sources.

  In addition, we support getting player scores with WeChat OpenID, parsing the score HTML, and uploading it to the data sources.



  ```bash
  pip install maimai-py
  ```

  To upgrade:

  ```bash
  pip install -U maimai-py
  ```

  For more, read the docs: https://maimai-py.pages.dev/.



  ```python
  import asyncio
  from maimai_py import MaimaiClient, MaimaiPlates, MaimaiScores, MaimaiSongs, PlayerIdentifier, LXNSProvider, DivingFishProvider


  async def quick_start():
      maimai = MaimaiClient()
      divingfish = DivingFishProvider(developer_token="")

      
      songs: MaimaiSongs = await maimai.songs()
      
      scores: MaimaiScores = await maimai.scores(PlayerIdentifier(username="turou"), provider=divingfish)
      
      plates: MaimaiPlates = await maimai.plates(PlayerIdentifier(username="turou"), "舞将", provider=divingfish)

      song = songs.by_id(1231)  # 生命不詳 by 蜂屋ななし

      print(f"Song 1231: {song.artist} - {song.title}")
      print(f"TuRou's rating: {scores.rating}, b15 top rating: {scores.scores_b15[0].dx_rating}")
      print(f"TuRou's 舞将: {plates.cleared_num}/{plates.all_num} cleared")

  asyncio.run(quick_start())
  ```



  maimai.py is fully asynchronous by default, and there are no plans to provide synchronous methods.

  If you don't want to be asynchronous, you can use the `asyncio.run` wrapper to call asynchronous methods synchronously.



  You can checkout our api docs at https://maimai-py.pages.dev/.

  User friendly documentations are still under development.


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

  The Mainstay Python library provides convenient access to the Mainstay 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 [docs.mainstay.io](https://docs.mainstay.io). The full API of this library can be found in [api.md](https://github.com/mainstay-io/mainstay-python/tree/main/api.md).



  ```sh

  pip install --pre mainstay
  ```



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

  ```python
  import os
  from mainstay import Mainstay

  client = Mainstay(
      api_key=os.environ.get("MAINSTAY_API_KEY"),  # This is the default and can be omitted
      
      environment="staging",
  )

  property_details_response = client.data.property_details._fetch(
      addresses=[
          {
              "city": "San Antonio",
              "postal_code": "78253",
              "state": "TX",
              "street": "14042 Kenyte Row",
          }
      ],
  )
  print(property_details_response.results)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `MAINSTAY_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncMainstay` instead of `Mainstay` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from mainstay import AsyncMainstay

  client = AsyncMainstay(
      api_key=os.environ.get("MAINSTAY_API_KEY"),  # This is the default and can be omitted
      
      environment="staging",
  )


  async def main() -> None:
      property_details_response = await client.data.property_details._fetch(
          addresses=[
              {
                  "city": "San Antonio",
                  "postal_code": "78253",
                  "state": "TX",
                  "street": "14042 Kenyte Row",
              }
          ],
      )
      print(property_details_response.results)


  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 `mainstay.APIConnectionError` is raised.

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

  All errors inherit from `mainstay.APIError`.

  ```python
  import mainstay
  from mainstay import Mainstay

  client = Mainstay()

  try:
      client.data.property_details._fetch(
          addresses=[
              {
                  "city": "San Antonio",
                  "postal_code": "78253",
                  "state": "TX",
                  "street": "14042 Kenyte Row",
              }
          ],
      )
  except mainstay.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except mainstay.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except mainstay.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 mainstay import Mainstay


  client = Mainstay(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).data.property_details._fetch(
      addresses=[
          {
              "city": "San Antonio",
              "postal_code": "78253",
              "state": "TX",
              "street": "14042 Kenyte Row",
          }
      ],
  )
  ```



  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 mainstay import Mainstay


  client = Mainstay(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).data.property_details._fetch(
      addresses=[
          {
              "city": "San Antonio",
              "postal_code": "78253",
              "state": "TX",
              "street": "14042 Kenyte Row",
          }
      ],
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/mainstay-io/mainstay-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 `MAINSTAY_LOG` to `info`.

  ```shell
  $ export MAINSTAY_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 mainstay import Mainstay

  client = Mainstay()
  response = client.data.property_details.with_raw_response._fetch(
      addresses=[{
          "city": "San Antonio",
          "postal_code": "78253",
          "state": "TX",
          "street": "14042 Kenyte Row",
      }],
  )
  print(response.headers.get('X-My-Header'))

  property_details = response.parse()  # get the object that `data.property_details._fetch()` would have returned
  print(property_details.results)
  ```

  These methods return an [`APIResponse`](https://github.com/mainstay-io/mainstay-python/tree/main/src/mainstay/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/mainstay-io/mainstay-python/tree/main/src/mainstay/_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.data.property_details.with_streaming_response._fetch(
      addresses=[
          {
              "city": "San Antonio",
              "postal_code": "78253",
              "state": "TX",
              "street": "14042 Kenyte Row",
          }
      ],
  ) 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 mainstay import Mainstay, DefaultHttpxClient

  client = Mainstay(
      
      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/mainstay-io/mainstay-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 mainstay
  print(mainstay.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/mainstay-io/mainstay-python/tree/main/./CONTRIBUTING.md).


pkgId: 62e3e31b51520e0561b6f0762f75f18839a6da3221e9cfd435999f6736c80b2d
name: python-maitai-python-help
arch: noarch
version: 1.1.45
epoch: 0
release: 1
summary: Development documents and examples for maitai-python
url: https://docs.trymaitai.ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maitai-python-1.1.45-1.src.rpm
location_href: Packages/python-maitai-python-help-1.1.45-1.noarch.rpm
checksum_type: sha256
description:
  Full docs can be found at https://docs.trymaitai.ai



  Install the Maitai SDK:

  ```bash
  pip install maitai-python
  ```



  Implementing Maitai into your application requires minimal code changes.

  ```python
  import maitai

  messages = [
      {"role": "system", "content": "You are a helpful ordering assistant..."},
      {"role": "user", "content": "Generate a response to the customer..."},
  ]

  response = maitai.chat.completions.create(
      messages=messages,
      model="llama3-70b-8192",  ## Remove this line to set model in Portal
      session_id="YOUR_SESSION_ID",
      intent="CONVERSATION",
      application="YOUR_APPLICATION_NAME",
  )
  ```

  **Note**
  Maitai requires `openai` version `1.30.1` or later. If you are using an older version, please upgrade.



  Run your application, make sure it makes at least one Chat Completion Request, then head over
  to https://portal.trymaitai.ai and watch Maitai learn your application in real time.


pkgId: 12ce06aa96e3c34efb1a9794e89f5d4376c83a376575c08c00a7b96667d59fe3
name: python-make-c-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for make-c
url: https://github.com/zcutlip/make_c_program
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-make-c-0.2.0-1.src.rpm
location_href: Packages/python-make-c-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  A script to generate a simple C program with a few basic includes and a `main()`. Then it opens the file in your editor of choice placing the cursor at the proper line and column to start adding code.

  Supported editors include:

  - vim
  - SublimeText (`subl`)
  - TextMate (`mate`)
  - Visual Studio Code (`code`)
  - nano
  - emacs



  ```console
  $ pip3 install make-c
  ```



  Help output:

  ```console
  $ make_c --help
  usage: make_c [-h] [-l] [--version] [--editor EDITOR] [--skip-editor] [-T]
                [-M]
                [filename]

  make_c: A utility to create a simple C source file with a main and open it in
  an editor. version 0.2.0

  positional arguments:
    filename              Name of the source file to create.

  options:
    -h, --help            show this help message and exit
    -l, --list-editors    List known editors.
    --version             Print version string and exit.
    --editor EDITOR       Editor to use to open the resulting source file.
    --skip-editor         Create the source file but don't open it in an editor.
    -T, --tabs            Use tabs instead of spaces.
    -M, --generate-makefile
                          Create a makefile to build the program.
  ```

  List available editors:

  ```console
  $ make_c --list-editors
  Known editors:

  vim: Vi IMproved, a programmer's text editor
  subl: Sublime Text 3
  mate: TextMate 2
  code: Visual Studio Code
  emacs: GNU project Emacs editor
  nano: Nano's ANOther editor, an enhanced free Pico clone
  ```

  If an editor isn't provided on the command line, it can be specified using an environment. The variables that are used are, in the following order:

  1. `MAKE_C_EDITOR`
  2. `EDITOR`
  3. `VISUAL`

  Creating and editing a file:

  ```console

  $ make_c foo.c


  $ export MAKE_C_EDITOR=/usr/local/bin/emacs
  $ make_c foo.c


  $ unset MAKE_C_EDITOR
  $ export EDITOR=/usr/bin/vim



  $ make_c foo.c --editor=subl



  $ make_c foo.c --generate-makefile
  ```



  To add additional editors, extend the `CProgram` class and override:

  - The `EDITOR` class variable
  - The `DESCRIPTION` class variable
  - The `generate_editor_command()` instance method

  The string representation for `--list-editors` is automatically generated by the superclass from `EDITOR` and `DESCRIPTION`.

  The `generate_editor_command()` method should return an `argv` that represents that editor's commandline incantation in list form suitable for consumption by `subprocess.Popen()`. For example, if your editor takes a `--line` and `--column` argument, you would return:

  ```python
  def generate_editor_command(self):
      return [self.generate_editor_arg0(),
              "--line",
              "%d" % self.edit_line,
              "--column",
              "%d" % self.edit_column,
              self.filename]
  ```


pkgId: 576877c1d30478196b450bd1cc543cf39f966ae601d609f9d05512c63065d738
name: python-makefilename-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for makefilename
url: https://pypi.org/project/makefilename/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-makefilename-0.1.0-1.src.rpm
location_href: Packages/python-makefilename-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Takes an input string + extension and turns it into a sanitized filename.

      from makefilename import make_filename

      filename = make_filename()


pkgId: 5fc94fae9ed1db89082061313a3420fa7c0f26bfc0ac2a619b77fda9cc5213e3
name: python-malette-awe-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for malette-awe
url: https://github.com/maletteAI/awe
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-malette-awe-0.1.4-1.src.rpm
location_href: Packages/python-malette-awe-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  AWE 是一个 AI 工作流引擎,用于对接 ComfyUI 并提供工作流调度能力。



  - 支持通过 RocketMQ 接收任务请求
  - 支持调用 ComfyUI API 执行工作流
  - 支持工作流模板和参数配置
  - 支持进度、错误、完成事件通知
  - 支持中英文提示词翻译
  - 支持图片上传和结果处理



  ```bash
  pip install malette-awe
  ```



  需要配置以下环境变量:

  ```bash

  COMFYUI_HOST=localhost
  COMFYUI_PORT=8188

  ROCKETMQ_ENDPOINT=xxx
  ROCKETMQ_ACCESS_KEY=xxx
  ROCKETMQ_ACCESS_SECRET=xxx
  ROCKETMQ_INSTANCE_ID=xxx
  ROCKETMQ_BASE_REQUEST_TOPIC=xxx
  ROCKETMQ_BASE_RESPONSE_TOPIC=xxx
  ROCKETMQ_BASE_GROUP_ID=xxx
  ROCKETMQ_MESSAGE_TAG=xxx
  ROCKETMQ_STATIC_TOPIC=false
  ROCKETMQ_STATIC_GROUP=false

  DASHSCOPE_API_KEY=xxx

  ENV=dev
  APPNAME=your_app_name
  ```



  ```python
  from awe import AWE


  awe = AWE(
    comfyui_host="localhost",
    comfyui_port="8188"
  )

  awe.start()
  ```



  安装测试依赖:

  ```bash
  pip install -e ".[test]"
  ```

  运行测试:

  ```bash
  pytest tests/
  ```

  运行测试覆盖率报告:

  ```bash
  pytest --cov=src tests/
  ```


pkgId: 520d5953719848902977f6be317e31e654524da945ec97f38d784a1c9ce27a74
name: python-mammoth-nlp-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for mammoth-nlp
url: https://pypi.org/project/mammoth-nlp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mammoth-nlp-0.2.1-1.src.rpm
location_href: Packages/python-mammoth-nlp-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains the code for 🦣 MAMMOTH, the modular translation toolkit from Helsinki-NLP.

  This library is built on top of OpenNMT-py.
  [OpenNMT-py](https://github.com/OpenNMT/OpenNMT-py) is the [PyTorch](https://github.com/pytorch/pytorch) version of the [OpenNMT](https://opennmt.net) project, an open-source (MIT) neural machine translation framework. It is designed to be research friendly to try out new ideas in translation, summary, morphology, and many other domains. Some companies have proven the code to be production ready.


  The original ONMT-py documentation is available [here](https://opennmt.net/OpenNMT-py/).
  Our own modifications (currently-under-development) are documented [here](https://helsinki-nlp.github.io/mammoth/).

  FINAL NOTE: We would appreciate it A LOT if you report issues with this repo and/or the documentation


  We thank the NVIDIA AI Technology Center Finland for their help with the multi-gpu/node implementation.


pkgId: 22509a2d67a3aa94b25122511990c5f96b11de3c67aa773601a31c063b72543a
name: python-manim-chemistry-help
arch: noarch
version: 0.4.3
epoch: 0
release: 1
summary: Development documents and examples for manim-chemistry
url: https://github.com/UnMolDeQuimica/manim-Chemistry
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-manim-chemistry-0.4.3-1.src.rpm
location_href: Packages/python-manim-chemistry-help-0.4.3-1.noarch.rpm
checksum_type: sha256
description:
  Check out the brand new [docs](https://manim-chemistry.readthedocs.io/en/latest/)!

  (They are still in progress)


  - [Installation](#installation)
  - [What is manim-Chemistry](#what-is-manim-chemistry)
  - [What can manim-Chemistry do right now?](#what-can-manim-chemistry-do-right-now)
  - [Create 2D molecules](#create-2d-molecules)
  - [Create 3D molecule](#create-3d-molecule)
  - [Create a periodic table](#create-a-periodic-table)
  - [Making atomic orbitals](#making-atomic-orbitals)
  - [Making Bohr diagrams](#making-bohr-diagrams)
  - [Reading .mol files](#reading-mol-files)
  - [Typical issues with .mol files](#typical-issues-with-mol-files)
  - [Take a look to examples](#)
  - [Made with manimChemistry](#made-with-manimchemistry)
  - [How to contact](#how-to-contact)
  - [Great contributers](#great-contributers)



  You can install via pip:

  ```
  pip install manim_chemistry
  ```

  You can also clone the repo and install it from here:

  ```
  git clone https://github.com/UnMolDeQuimica/manim-Chemistry.git
  cd manim-Chemistry
  python -m pip install .
  ```

  or

  ```
  git clone https://github.com/UnMolDeQuimica/manim-Chemistry.git
  cd manim-Chemistry
  python -m pip install -e .
  ```




  manim-Chemistry is a manim plugin designed to make chemistry animations easier.

  To my knowledge, there is only another plugin related to chemistry called [chanim](https://github.com/kilacoda/chanim) that aims to import to manim the chemfig package (and does an amazing job!).

  The philosophy of manim-Chemistry goes into a different direction: manim-Chemistry tries to use the manim tools in combination with [.mol](https://en.wikipedia.org/wiki/Chemical_table_file) files and [.csv](https://en.wikipedia.org/wiki/Comma-separated_values) databases useful basic classes to create beatufil chemistry related animations such as a Periodic Table or 2d and 3d chemical structures.

  Also, manim-Chemistry will try to do as much things from scratch as possible. That means I will also avoid using libraries such as [Mendeleev](https://mendeleev.readthedocs.io/en/stable/), [RDKit](https://www.rdkit.org/), [PyMOL](https://pymol.org/2/), [Open Babel](https://openbabel.org/wiki/Main_Page) ammong others. The reason is avoid depending on 3rd party packages that might need intensive maintenance. However, the users can combine the power of those libraries with manim-Chemistry to make life easier.

  This project is still a work in progress and there is no date for a final realease yet.



  This will be a summary of the capabilities of manim-Chemistry. As this project is still in progress this might not be up to date. Check the examples to get a better idea of what you can do. You might want to check the TODO file to know what is comming and yet to be done. Feel free to open issues and pull requests to make this even greater!



  To create 2D molecules you simply need a .mol file with atoms and bonds data. Take a look at the morphine.mol file inside examples to know how should it look.

  To create a Scene with a 2D molecule you should have a structure like this:

  ```
  from manim import *
  from manim_chemistry import *

  class TwoDMoleculeScene(Scene):
     def construct(self):
          morphine = MMoleculeObject.from_mol_file("morphine.mol")
          self.add(morphine)
  ```

  You can run manim as usual:

  `manim .\examples.py -ps`

  The result looks like this:

  ![plot](/examples/examples_assets/2D_morphine_bad.png)

  Doesn't look really good, right? Double bonds are not in the correct position. We can solve this!

  You can set to True an option to see the bonds numbering. You can do a similar thing to the atoms. This numbering is given by the .mol file and is NOT related to the chemical strucure.

  ```
  from manim import *
  from manim_chemistry import *

  class TwoDMoleculeScene(Scene):
     def construct(self):
          morphine = MMoleculeObject.from_mol_file("morphine.mol", add_bonds_numbering=True)
          self.add(morphine)
  ```

  We get

  ![plot](/examples/examples_assets/2D_morphine_bond_numbering.png)

  So we need to rotate bonds 7 and 20. We can add this adding their index to the rotate_bonds list:

  ```
  from manim import *
  from manim_chemistry import *

  class TwoDMoleculeScene(Scene):
     def construct(self):
          morphine = MMoleculeObject.from_mol_file("morphine.mol", rotate_bonds=[7, 20])
          self.add(morphine)
  ```

  Result:
  ![plot](/examples/examples_assets/2D_morphine_corrected_bonds.png)

  Now we are talking!



  You may want to add a name to a molecule. It is very simple, but it is handy to do all in the same object. You can create a NamedMolecule similarly to how you create a MMoleculeObject:

  ```
  from manim import *
  from manim_chemistry import *

  class NamedMoleculeExample(Scene):
      def construct(self):
          named_molecule = NamedMolecule.from_mol_file(name="Morphine", filename="morphine.mol")
          self.add(diagram)
  ```
  ![plot](/examples/examples_assets/NamedMoleculeExample_ManimCE_v0.17.3.png)

  You can also provided an already created molecule or an already created text and the NamedMolecule class will group them. This allows greater control for the user.


  Another variant of 2D molecules are the GraphMolecules. Those are based on Manim's Graph class, which gives them a lot of superpowers!

  You can use them in a very similar way as you did with MMolecules and NamedMolecules:

  ```
  from manim import *
  from manim_chemistry import *

  class GraphMoleculeExample(Scene):
      def construct(self):
          graph_molecule = GraphMolecule.build_from_mol(mol_file="morphine.mol")
          self.add(graph_molecule)
  ```
  ![plot](/examples/examples_assets/DrawGraphMorphine_ManimCE_v0.17.3.png)

  There you go!

  You can also add a label by setting `label=True` when building the GraphMolecule:
  ```
  from manim import *
  from manim_chemistry import *

  class GraphMoleculeExample(Scene):
      def construct(self):
          graph_molecule = GraphMolecule.build_from_mol(
              mol_file="morphine.mol",
              label=True
          )
          self.add(graph_molecule)
  ```
  ![plot](/examples/examples_assets/DrawLabeledGraphMorphine_ManimCE_v0.17.3.png)

  Using `label=True` and `numeric_label=True` you will get the molecule drawn with is atoms labeled using the molfile:
  ```
  from manim import *
  from manim_chemistry import *

  class GraphMoleculeExample(Scene):
      def construct(self):
          graph_molecule = GraphMolecule.build_from_mol(
              mol_file="morphine.mol",
              label=True,
              numeric_label=True
          )
          self.add(graph_molecule)
  ```
  ![plot](/examples/examples_assets/DrawLabeledWithIndexGraphMorphine_ManimCE_v0.17.3.png)


  The power of graphs really shows in GraphMolecules. One of the examples of this power is using `networkx` to get parts of the molecules given a starting atom and ending atom. For example, we could color a part of the molecule:


  ```python
  class GraphMoleculeExample(Scene):
      def construct(self):
          molecule = GraphMolecule.build_from_mol(asset, label=True, numeric_label=True)
          atoms_and_bonds = molecule.get_connected_atoms_and_bonds(1, 3)
          atoms_and_bonds.set_color(GREEN)
          self.add(molecule)
  ```
  ![plot](/examples/examples_assets/PartiallyColoredGraphMolecule.png)



  It is also possible to perform some custom animations using GMAnimationBuilder: rotate_atoms_about_bond and change_color:

  ![plot](/examples/examples_assets/CustomGraphMoleculeAnimation.gif)





  Creating a 3D molecule requires a bit more effort. We need two things:

  1. A .mol file (like before)
  2. A csv data file with data for your atoms. You can find an example inside the examples folder called "Elementos.csv".

  The .mol will be parsed and the .csv will tell manim-Chemistry some data, specially the color. Using the same file as before we can create a 3D structure for morphine:

  ```
  from manim import *
  from manim_chemistry import *

  class Draw3DMorphine(ThreeDScene):
      def construct(self):
          three_d_morphine = ThreeDMolecule.from_mol_file("morphine.mol", "Elementos.csv")
          self.add(three_d_morphine)
          self.wait()
  ```

  To be able to run this you need to run manim using opengl as renderer:

  `manim .\examples.py Draw3DMorphine -ps --renderer=opengl`

  Here is the result!

  ![plot](/examples/examples_assets/Draw3DMorphine_ManimCE_v0.17.3.png)

  As you can see, the coloring is defined in the "Elementos.csv" file, but you can make your own source file to customize colors!



  Like before, we need a source file to draw everything. Again, feel free to make your own from a copy of "Elementos.csv"

  You can create the frame for an element using:

  ```
  from manim import *
  from manim_chemistry import *

  class DrawCarbonElement(Scene):
      def construct(self):
          carbon = MElementObject.from_csv_file_data(filename="Elementos.csv", atomic_number=6)
          self.add(carbon)
  ```

  And there you have it!

  ![plot](/examples/examples_assets/DrawCarbonElement_ManimCE_v0.17.3.png)


  To make the whole periodic table you need data for every element inside that data source file. Elementos.csv already has it, so you just have to copy it and adapt to your needs. Using the cpk coloring and the following code we get that beautiful periodic table:

  ```
  from manim import *
  from manim_chemistry import *

  class DrawPeriodicTable(Scene):
      def construct(self):
          self.add(PeriodicTable(data_file="Elementos.csv"))
  ```

  ![plot](/examples/examples_assets/DrawPeriodicTable_ManimCE_v0.17.3.png)




  Molecular orbitals are very complex and consuming for a simple python script, but we can get atomic orbitals pretty easily just by selecting the l and m level we want to plot:

  ```
  from manim import *
  from manim_chemistry import *

  class DrawPOrbital(Scene):
      def construct(self):
          orbital = Orbital(l=1, m=-1)
          self.add(orbital)
  ```

  One again you need to use opengl as renderer:

  `manim .\examples.py DrawPOrbital -ps --renderer=opengl`

  ![plot](/examples/examples_assets/orbitals_example.png)



  Bohr diagrams are very outdated, but drawing them might be usefull to communicate certain ideas. Here all you have to do is set the number of protons, electrons and neutrons and you will get a nice diagram:

  ```
  from manim import *
  from manim_chemistry import *

  class DrawBohrDiagram(Scene):
      def construct(self):
          diagram = BohrAtom(e=14, p=14,, n=10)
          self.add(diagram)
  ```
  Here you have your nice diagram!

  ![plot](/examples/examples_assets/BohrDiagram_ManimCE_v0.17.3.png)





  manim-Chemistry can parse .mol files to create a dictionary with atoms and bond data. Currently, the data we are getting is:



  - Index: To know the index in the .mol file, which allows us to keep track of bonding.
  - Coordinates: Used to give a position to the atom.
  - Element: To know which element is it.
  - Bond to. Using the index of other atoms, we get to know to which atoms is bond a certain atom.



  - From atom: The index of the atom starting the bond
  - To atom: The index of the atom ending the bond
  - Type: Indicates the type of bond. Check[the bond block specifications](https://en.wikipedia.org/wiki/Chemical_table_file#Bond_block_specification) for further info.
  - Stereo: Usefull to know if a cram bond is needed and which kind.



  This is used inside both 2d and 3d molecules but can be used independently importing it from the utils submodule.

  ```
  >>> from manim_chemistry.utils import mol_parser
  >>> morphine_parsed = mol_parser("morphine.mol")
  >>> morphine_parsed
  ({1: {'coords': array([ 0.   , -0.825,  0.   ]), 'element': 'C', 'bond_to': {7: 'C', 2: 'C', 3: 'C'}}, 2: {'coords': array([-0.7145, -0.4125,  0.    ]), 'element': 'C', 'bond_to': {1: 'C', 12: 'O', 4: 'C'}}, 3: {'coords': array([ 0.7145, -0.4125,  0.    ]), 'element': 'C', 'bond_to': {1: 'C', 14: 'C', 5: 'C'}}, 4: {'coords': array([-0.7145,  0.4125,  0.    ]), 'element': 'C', 'bond_to': {2: 'C', 18: 'O', 6: 'C'}}, 5: {'coords': array([0.7145, 0.4125, 0.    ]), 'element': 'C', 'bond_to': {3: 'C', 6: 'C'}}, 6: {'coords': array([0.   , 0.825, 0.   ]), 'element': 'C', 'bond_to': {4: 'C', 5: 'C'}}, 7: {'coords': array([ 0.003 , -1.6464,  0.    ]), 'element': 'C', 'bond_to': {1: 'C', 8: 'C', 9: 'C', 22: 'C'}}, 8: {'coords': array([ 0.7109, -2.0631,  0.    ]), 'element': 'C', 'bond_to': {7: 'C', 10: 'C', 11: 'C', 20: 'H'}}, 9: {'coords': array([-0.7127, -2.0511,  0.    ]), 'element': 'C', 'bond_to': {7: 'C', 12: 'O', 13: 'C'}}, 10: {'coords': array([ 1.4268, -1.651 ,  0.    ]), 'element': 'C', 'bond_to': {8: 'C', 15: 'N', 14: 'C'}}, 11: {'coords': array([ 0.7067, -2.8808,  0.    ]), 'element': 'C', 'bond_to': {8: 'C', 16: 'C'}}, 12: {'coords': array([-1.5371, -1.1745,  0.    ]), 'element': 'O', 'bond_to': {2: 'C', 9: 'C'}}, 13: {'coords': array([-0.7206, -2.8689,  0.    ]), 'element': 'C', 'bond_to': {9: 'C', 17: 'O', 16: 'C'}}, 14: {'coords': array([ 1.431 , -0.8297,  0.    ]), 'element': 'C', 'bond_to': {3: 'C', 10: 'C'}}, 15: {'coords': array([ 2.1419, -2.0715,  0.    ]), 'element':
  'N', 'bond_to': {10: 'C', 19: 'C', 21: 'C'}}, 16: {'coords': array([-0.0128, -3.2891,  0.    ]), 'element': 'C', 'bond_to': {11: 'C', 13: 'C'}}, 17: {'coords': array([-1.4365, -3.2845,  0.    ]), 'element': 'O', 'bond_to': {13: 'C'}}, 18: {'coords': array([-1.4262,  0.8296,  0.    ]), 'element': 'O', 'bond_to': {4: 'C'}}, 19: {'coords': array([ 2.9416, -1.853 ,  0.    ]), 'element': 'C', 'bond_to': {15: 'N'}}, 20: {'coords': array([ 1.4954, -2.6258,  0.    ]), 'element': 'H', 'bond_to': {8: 'C'}}, 21: {'coords': array([ 2.1397, -1.2341,  0.    ]), 'element': 'C', 'bond_to': {15: 'N', 22: 'C'}}, 22: {'coords': array([ 0.7183, -1.233 ,  0.    ]), 'element': 'C', 'bond_to': {7: 'C', 21: 'C'}}}, {7: [{'to': 1, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 8, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 9, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 22, 'type': '1', 'stereo': 1, 'topology': 0, 'reacting_center_status': 0}], 1: [{'to': 2, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 3, 'type': '2', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 2: [{'to': 12, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 4, 'type': '2', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 3: [{'to': 14, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 5, 'type': '1', 'stereo': 0, 'topology': 0,
  'reacting_center_status': 0}], 4: [{'to': 18, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 6, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 5: [{'to': 6, 'type': '2', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 8: [{'to': 10, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 11, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}, {'to': 20, 'type': '1', 'stereo': 1, 'topology': 0, 'reacting_center_status': 0}], 9: [{'to': 12, 'type': '1',
  'stereo': 6, 'topology': 0, 'reacting_center_status': 0}, {'to': 13, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 10: [{'to': 15, 'type': '1', 'stereo': 1, 'topology': 0, 'reacting_center_status': 0}, {'to': 14, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 11: [{'to': 16, 'type': '2', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 13: [{'to': 17, 'type': '1', 'stereo': 6, 'topology': 0, 'reacting_center_status': 0}, {'to': 16, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status':
  0}], 15: [{'to': 19, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 21: [{'to': 15, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}], 22: [{'to': 21, 'type': '1', 'stereo': 0, 'topology': 0, 'reacting_center_status': 0}]}
  ```



  Sometimes you are trying to draw a molecule with a lot of atoms and bonds. This results in a file that looks like this:

  ```
    ACD/LABS04302300463D

  216265  0  0  0  0  0  0  0  0  1 V2000
     16.2474   -9.9960    2.4976 P   0  0  0  0  0  0  0  0  0  0  0  0
     17.2414   -9.9960    1.6140 P   0  0  0  0  0  0  0  0  0  0  0  0
     16.2474  -11.2601    0.2434 P   0  0  0  0  0  0  0  0  0  0  0  0
     17.2414  -11.2601    1.1271 P   0  0  0  0  0  0  0  0  0  0  0  0
  .
  .
  .
  ```

  See that 216265? This is a problem. manimChemistry will think this is the number of atoms we have and this is a problem. At this stage of the development we need to manually correct this. In this example, we have 216 atoms and 265 bonds, so we have to separate it:

  ```
    ACD/LABS04302300463D

  216 265  0  0  0  0  0  0  0  0  1 V2000
     16.2474   -9.9960    2.4976 P   0  0  0  0  0  0  0  0  0  0  0  0
     17.2414   -9.9960    1.6140 P   0  0  0  0  0  0  0  0  0  0  0  0
     16.2474  -11.2601    0.2434 P   0  0  0  0  0  0  0  0  0  0  0  0
     17.2414  -11.2601    1.1271 P   0  0  0  0  0  0  0  0  0  0  0  0
  .
  .
  .
  ```

  Our problems are not solved. Probably some bonds will look like this:

  ```
  213215  1  0  0  0  0
  201207  1  0  0  0  0
  214202  1  0  0  0  0
  214216  1  0  0  0  0

  ```

  This 213215, 201207, 214202, 214216 are, in fact, bonds pointing from atom 213 to 215, 201 to 207, 214 to 202 and 214 to 216. We must solve this manually again:

  ```
  213 215  1  0  0  0  0
  201 207  1  0  0  0  0
  214 202  1  0  0  0  0
  214 216  1  0  0  0  0

  ```




  Inside this repo there is a folder examples with assets and basic files that might be useful. Make sure to check them!



  Here you have some examples using manimChemistry. Feel free to contribute with your own animations and videos!

  Fullerene:
  ![plot](/examples/examples_assets/Fullerene.png)

  Beta and alpha tin structures:
  ![plot](/examples/examples_assets/TinPhases.png)

  Videos using manimChemistry:

  https://www.youtube.com/watch?v=L7OXe94_WmA

  https://youtu.be/KgiCl_o_Aws



  You can open issues and pull requests, but if you want to contact me directly you can go to:
  - Email: unmoldequimica@gmail.com
  - YouTube: https://www.youtube.com/@unmoldequimica
  - Twitter: https://twitter.com/unmoldequimica



  - [@chemnerd28](https://github.com/chemnerd28)
  - [@Ant-28](https://github.com/Ant-28)


  Special thanks to [@Rodrigo-Tenorio](https://github.com/Rodrigo-Tenorio) for his help in the creation of this releasable package.

rpm_license:
  MIT License  Copyright (c) 2023 UMDQ  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: 88db61961a27dc9ed03ec0910069fb54e6059771dccff2f5fd7118b62dd4138f
name: python-manufacturing-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for manufacturing
url: https://pypi.org/project/manufacturing/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-manufacturing-1.6.0-1.src.rpm
location_href: Packages/python-manufacturing-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  To provide analysis tools and metrics useful in manufacturing environments.

  Go to the [documentation](https://slightlynybbled.github.io/manufacturing/index.html).



  Plots and project are reasonably mature at this point.  Calculations have been refined
  and are in-line with commonly accepted standards.

  A major v2.0 update is coming to control charts and will be available in
  `manufacturing.alt_vis` module.  For instance, instead of using `from manufacturing import x_mr_chart`,
  you would use `from manufacturing.alt_vis import x_mr_chart`.  The new API should
  allow for a greater degree of flexibility with recalculation points and the ability
  to relabel the axes.  Additionally, alternative axis labels will be able to be supplied.
  These changes will eventually become "the way", but are to be considered experimental
  until the v2.0 update.



  To install from `pypi`:

      $>pip install manufacturing



  This package uses [uv](https://docs.astral.sh/uv/) to manage the workflow.

      $>git clone <this repository>
      $>cd manufacturing
      $manufacturing/>uv build



  Tests will take a while to run - it is generating several hundred plots in the background.

      $>uv run pytest





  The most useful feature of the `manufacturing` package is the visualization of Cpk.
  As hinted previously, the `ppk_plot()` function is the primary method for display of
  Cpk visual information.  First, get your data into a `list`, `numpy.array`, or
  `pandas.Series`; then supply that data, along with the `lower_control_limit` and
  `upper_control_limit` into the `ppk_plot()` function.

      manufacturing.ppk_plot(data, lower_specification_limit=-2, upper_specification_limit=2)

  ![Screenshot](images/example3.png)

  In this example, it appears that the manufacturing processes are not up to the task of
  making consistent product within the specified limits.



  Another useful feature is the zone control visualization.

      manufacturing.control_chart(data)

  There are X-MR charts, Xbar-R charts, and Xbar-S charts available as well.  If you call the
  `control_chart()` function, the appropriate sample size will be selected and data grouped as
  the dataset requires.  However, if you wish to call a specific type of control chart, use

   - `x_mr_chart`
   - `xbar_r_chart`
   - `xbar_s_chart`
   - `p_chart`



  Contributions are welcome!



  Items marked out were added most recently.

   - ...
   - ~~Add use github actions for deployment~~
   - ~~Transition to `poetry` for releases~~
   - ~~Add `I-MR Chart` (see `examples/imr_chart.py`)~~
   - ~~Add `Xbar-R Chart` (subgroups between 2 and 10)~~
   - ~~Add `Xbar-S Chart` (subgroups of 11 or more)~~
   - ~~Update documentation to reflect recent API changes~~
   - ~~Add `p chart`~~
   - Add `np chart`
   - Add `u chart`
   - Add `c chart`
   - Add automated testing (partially implemented)



  ![Ppk example](docs/_static/images/ppk_plot.png)

  ![Cpk example](docs/_static/images/cpk_plot.png)

  ![X-MR Chart](docs/_static/images/xmr_chart.png)

  ![Xbar-R Chart](docs/_static/images/xbarr_chart.png)

  ![Xbar-S Chart](docs/_static/images/xbars_chart.png)


pkgId: d0fa4ee1d623035d54708e3ddfbedd37a4b58b74c889dcdac8d59420bf47f37f
name: python-map2loop-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for map2loop
url: https://pypi.org/project/map2loop/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-map2loop-3.2.0-1.src.rpm
location_href: Packages/python-map2loop-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  - Developing with docker on Windows means you won't have GPU passthrough and can’t use a discrete graphics card in the container even if you have one.
  - If Jupyter links require a token or password, it may mean port 8888 is already in use. To fix, either make docker map to another port on the host ie -p 8889:8888 or stop any other instances on 8888.

  [https://loop3d.github.io/](https://loop3d.github.io/)
  [https://github.com/Loop3D/LoopStructural](https://github.com/Loop3D/LoopStructural)


pkgId: 0cc780774e9694f7f63fccb9579faa83db114a1735aacd56a4b217da8ed6b53f
name: python-maplestory-openapi-help
arch: noarch
version: 2.9.0
epoch: 0
release: 1
summary: Development documents and examples for maplestory-openapi
url: https://github.com/SpiralMoon/maplestory.openapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maplestory-openapi-2.9.0-1.src.rpm
location_href: Packages/python-maplestory-openapi-help-2.9.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/maplestory-openapi)](https://img.shields.io/pypi/v/maplestory-openapi)
  [![Python](https://github.com/SpiralMoon/maplestory.openapi/actions/workflows/python_test.yaml/badge.svg)](https://github.com/SpiralMoon/maplestory.openapi/actions/workflows/python_test.yaml)

  넥슨의 MapleStory OpenAPI를 Python 환경에서 사용할 수 있게 해주는 라이브러리입니다.

  다른 언어로 작성된 패키지는 [여기](https://github.com/SpiralMoon/maplestory.openapi)에서 확인할 수 있습니다.

  (English document is [HERE](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/README-en.md))



  python 기반 프로젝트에 아래 정보를 입력하여 패키지를 추가하세요:

  ```bash
  pip install maplestory-openapi
  ```





  라이브러리를 사용하기 전에 [Nexon Open API 콘솔](https://openapi.nexon.com/my-application/)에서 애플리케이션을 등록하고 **api key**를 발급 받으세요.



  아래 코드는 닉네임을 바탕으로 특정 캐릭터의 식별자를 조회한 후 캐릭터의 기본 정보를 조회하는 예시입니다.

  ```python
  from maplestory_openapi import MapleStoryApi
  from maplestory_openapi.api.maplestory_api_error import MapleStoryApiException

  api_key = '{Your API Key}'
  api = MapleStoryApi(api_key=api_key)


  try:
      character = api.get_character_id('{Your Character Name}')
      character_basic = api.get_character_basic(ocid=character.ocid)

      print(character_basic)

  except MapleStoryApiException as e:
      
  ```

  더 많은 예시는 아래 링크의 테스트 케이스에서 확인할 수 있습니다.

  - [캐릭터 정보 조회](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/test/character_api_test.py)
  - [유니온 정보 조회](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/test/union_api_test.py)
  - [길드 정보 조회](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/test/guild_api_test.py)
  - [확률 정보 조회](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/test/history_api_test.py)
  - [랭킹 정보 조회](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/test/ranking_api_test.py)
  - [공지 정보 조회](https://github.com/SpiralMoon/maplestory.openapi/blob/master/python/test/notice_api_test.py)



  [MapleStory OpenAPI 가이드](https://openapi.nexon.com/guide/request-api)에 서술된 에러 사유를 `MapleStoryApiException`를 통해 예외 처리 해야합니다.

  `MapleStoryApi`는 특정 상태의 예외를 발생시키지 않도록 설계되었으나, 라이브러리를 사용하는 개발자의 실수로 인해 여전히 일부 상태의 예외가 발생할 수 있습니다.

  따라서 아래 표에 설명된 error code 목록을 기반으로 `MapleStoryApiException`를 예외 처리하시기 바랍니다.

  | ErrorCode    | Description       |
  |--------------|-------------------|
  | OPENAPI00001 | 서버 내부 오류          |
  | OPENAPI00002 | 권한이 없는 경우         |
  | OPENAPI00003 | 유효하지 않은 식별자       |
  | OPENAPI00004 | 파라미터 누락 또는 유효하지 않음 |
  | OPENAPI00005 | 유효하지 않은 API KEY   |
  | OPENAPI00006 | 유효하지 않은 API PATH  |
  | OPENAPI00007 | API 호출량 초과        |
  | OPENAPI00009 | 데이터 준비 중          |
  | OPENAPI00010 | 게임 점검 중           |
  | OPENAPI00011 | API 점검 중          |


pkgId: 53f458d2ee991813004075d1f9f1d26d9fee4eef9fdfe369fa75e1afa4aba904
name: python-maplibre-help
arch: noarch
version: 0.2.7
epoch: 0
release: 1
summary: Development documents and examples for maplibre
url: https://pypi.org/project/maplibre/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maplibre-0.2.7-1.src.rpm
location_href: Packages/python-maplibre-help-0.2.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Release](https://img.shields.io/github/v/release/eoda-dev/py-maplibregl)](https://img.shields.io/github/v/release/eoda-dev/py-maplibregl)
  [![pypi](https://img.shields.io/pypi/v/maplibre.svg)](https://pypi.python.org/pypi/maplibre)
  [![Conda recipe](https://img.shields.io/badge/recipe-maplibre-green.svg)](https://github.com/conda-forge/maplibre-feedstock)
  [![Conda package](https://img.shields.io/conda/vn/conda-forge/maplibre.svg)](https://anaconda.org/conda-forge/maplibre)
  [![Build status](https://img.shields.io/github/actions/workflow/status/eoda-dev/py-maplibregl/pytest.yml?branch=main)](https://img.shields.io/github/actions/workflow/status/eoda-dev/py-maplibregl/pytest.yml?branch=main)
  [![License](https://img.shields.io/github/license/eoda-dev/py-maplibregl)](https://img.shields.io/github/license/eoda-dev/py-maplibregl)
  [![MapLibre](https://img.shields.io/badge/MapLibre.GL-v3.6.2-blue.svg)](https://github.com/maplibre/maplibre-gl-js/releases/tag/v3.6.2)

  MapLibre for Python provides Python bindings for [MapLibre GL JS](https://github.com/maplibre/maplibre-gl-js).
  Furthermore, [Deck.GL Layers](https://deck.gl/docs/api-reference/layers) can be mixed with [MapLibre Layers](https://maplibre.org/maplibre-style-spec/layers/).

  It integrates seamlessly into [Shiny for Python](https://github.com/posit-dev/py-shiny) and [Jupyter](https://jupyter.org/).



  ```bash

  pip install maplibre

  pip install "maplibre[all]"


  pip install git+https://github.com/eoda-dev/py-maplibregl@dev

  pip install "maplibre[all] @ git+https://github.com/eoda-dev/py-maplibregl@dev"


  conda install -c conda-forge maplibre
  ```



  ```python
  from maplibre import Map, MapOptions

  m = Map(MapOptions(center=(-123.1256, 49.24658), zoom=9))
  ```



  * [Basic usage](https://eoda-dev.github.io/py-maplibregl/)
  * [API Documentation](https://eoda-dev.github.io/py-maplibregl/api/map/)
  * [Examples](https://eoda-dev.github.io/py-maplibregl/examples/every_person_in_manhattan/)





  ```bash
  poetry install

  poetry run pytest

  poetry run pytest --ignore=maplibre/ipywidget.py --doctest-modules maplibre
  ```



  ```bash
  npm install

  npm run prettier

  npm run build

  npm run build-ipywidget
  ```


pkgId: 552ae118a87ae2995ef6c9ebd9968daf76a25645ad11af867d81c7221ef44a66
name: python-mapreader-help
arch: noarch
version: 1.6.1
epoch: 0
release: 1
summary: Development documents and examples for mapreader
url: https://github.com/Living-with-machines/MapReader
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mapreader-1.6.1-1.src.rpm
location_href: Packages/python-mapreader-help-1.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <!--- sphinx-include --->

  **MapReader is a open-source python library for exploring and analyzing map images at scale.**
  It contains two different pipelines:
  - Classification pipeline: This pipeline enables users to fine-tune a classification model and predict the labels of patches created from a parent image.
  - Text spotting pipeline: This pipeline enables users to detect and recognize text in map images.
  MapReader was developed in the [Living with Machines](https://livingwithmachines.ac.uk/) project to analyze large collections of historical maps but is a _**generalizable**_ computer vision tool which can be applied to _**any images**_ in a wide variety of domains.


  The MapReader classification pipeline enables users to train a classification model to recognize visual features within map images and to identify patches containing these features across entire map collections:
  <figure align="center">
    <img src="https://raw.githubusercontent.com/maps-as-data/MapReader/main/docs/source/_static/pipeline_explained.png"
          alt="MapReader pipeline"
          width="70%">
  </figure>

  The MapReader text spotting pipeline enables users to detect and recognize text in map images using a pre-trained text spotting model:
  <figure align="center">
    <img src="https://raw.githubusercontent.com/maps-as-data/MapReader/main/docs/source/_static/text-spotting-pipeline.png"
          alt="MapReader text spotting pipeline"
          width="70%">
  </figure>

  The MapReader documentation can be found at https://mapreader.readthedocs.io/en/latest/.
  **New users** should refer to the [Installation instructions](https://mapreader.readthedocs.io/en/latest/getting-started/installation-instructions/index.html) and [Input guidance](https://mapreader.readthedocs.io/en/latest/using-mapreader/input-guidance/) for help with the initial set up of MapReader.
  **All users** should refer to our [User Guide](https://mapreader.readthedocs.io/en/latest/using-mapreader/) for guidance on how to use MapReader.
  This contains end-to-end instructions on how to use the MapReader pipeline.
   **Developers and contributors** may also want to refer to the [API documentation](https://mapreader.readthedocs.io/en/latest/in-depth-resources/api/mapreader/) and [Contribution guide](https://mapreader.readthedocs.io/en/latest/community-and-contributions/contribution-guide/) for guidance on how to contribute to the MapReader package.

  **All users** are encouraged to join our community! Please refer to the [Community and contributions](https://mapreader.readthedocs.io/en/latest/community-and-contributions/events.html) page for information on ways to get involved.
  **Join our Slack workspace!**
  Please fill out [this form](https://forms.gle/dXjECHZQkwrZ3Xpt9) to receive an invitation to the Slack workspace.

  This repository contains everything needed for running MapReader.
  The repository is structured as follows:
  - `mapreader/`: Contains the source code for the MapReader library.
  - `docs/`: Contains the documentation for the MapReader library.
  - `tests/` and `test_text_spotting/`: Contains the tests for the MapReader library.
  - `worked_examples/`: Contains worked examples of how to use the MapReader library.

  If you use MapReader in your work, please cite:
  - Our [JOSS paper](https://doi.org/10.21105/joss.06434) - to acknowledge the software irrespective of the version you used.
  - Our [Zenodo record](https://zenodo.org/records/13643609) - to acknowledge the specific version of the software you used (or use the "Cite all versions?" option if your specific version isn't there).
  - Optionally, our [SIGSPATIAL paper](https://dl.acm.org/doi/10.1145/3557919.3565812) to acknowledge the development of the software and the research behind it.
  <!-- Add bibtext entries for the papers here -->

  This work was supported by Living with Machines (AHRC grant AH/S01179X/1), Data/Culture (AHRC grant AH/Y00745X/1) and The Alan Turing Institute (EPSRC grant EP/N510129/1).
  Living with Machines, funded by the UK Research and Innovation (UKRI) Strategic Priority Fund, is a multidisciplinary collaboration delivered by the Arts and Humanities Research Council (AHRC), with The Alan Turing Institute, the British Library and the Universities of Cambridge, East Anglia, Exeter, and Queen Mary University of London.
  Maps above reproduced with the permission of the National Library of Scotland https://maps.nls.uk/index.html

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://www.turing.ac.uk/people/researchers/katherine-mcdonough"><img src="https://avatars.githubusercontent.com/u/20363927?v=4?s=100" width="100px;" alt="Katie McDonough"/><br /><sub><b>Katie McDonough</b></sub></a><br /><a href="#research-kmcdono2" title="Research">🔬</a> <a href="#ideas-kmcdono2" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/Living-with-machines/MapReader/commits?author=kmcdono2" title="Documentation">📖</a> <a href="#eventOrganizing-kmcdono2" title="Event Organizing">📋</a> <a href="#projectManagement-kmcdono2" title="Project Management">📆</a> <a href="https://github.com/Living-with-machines/MapReader/pulls?q=is%3Apr+reviewed-by%3Akmcdono2" title="Reviewed Pull Requests">👀</a> <a href="#talk-kmcdono2" title="Talks">📢</a> <a href="#tutorial-kmcdono2" title="Tutorials">✅</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://danielwilson.info"><img src="https://avatars.githubusercontent.com/u/34318222?v=4?s=100" width="100px;" alt="Daniel C.S. Wilson"/><br /><sub><b>Daniel C.S. Wilson</b></sub></a><br /><a href="#research-dcsw2" title="Research">🔬</a> <a href="#ideas-dcsw2" title="Ideas, Planning, & Feedback">🤔</a> <a href="#talk-dcsw2" title="Talks">📢</a> <a href="https://github.com/Living-with-machines/MapReader/commits?author=dcsw2" title="Documentation">📖</a> <a href="#eventOrganizing-dcsw2" title="Event Organizing">📋</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kasra-hosseini"><img src="https://avatars.githubusercontent.com/u/1899856?v=4?s=100" width="100px;" alt="Kasra Hosseini"/><br /><sub><b>Kasra Hosseini</b></sub></a><br /><a href="https://github.com/Living-with-machines/MapReader/commits?author=kasra-hosseini" title="Code">💻</a> <a href="#ideas-kasra-hosseini" title="Ideas, Planning, & Feedback">🤔</a> <a href="#research-kasra-hosseini" title="Research">🔬</a> <a href="https://github.com/Living-with-machines/MapReader/pulls?q=is%3Apr+reviewed-by%3Akasra-hosseini" title="Reviewed Pull Requests">👀</a> <a href="#talk-kasra-hosseini" title="Talks">📢</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/rwood-97"><img src="https://avatars.githubusercontent.com/u/72076688?v=4?s=100" width="100px;" alt="Rosie Wood"/><br /><sub><b>Rosie Wood</b></sub></a><br /><a href="https://github.com/Living-with-machines/MapReader/commits?author=rwood-97" title="Code">💻</a> <a href="https://github.com/Living-with-machines/MapReader/commits?author=rwood-97" title="Documentation">📖</a> <a href="#ideas-rwood-97" title="Ideas, Planning, & Feedback">🤔</a> <a href="#talk-rwood-97" title="Talks">📢</a> <a href="#tutorial-rwood-97" title="Tutorials">✅</a> <a href="https://github.com/Living-with-machines/MapReader/pulls?q=is%3Apr+reviewed-by%3Arwood-97" title="Reviewed Pull Requests">👀</a> <a href="#maintenance-rwood-97" title="Maintenance">🚧</a> <a href="#research-rwood-97" title="Research">🔬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.westerling.nu"><img src="https://avatars.githubusercontent.com/u/7298727?v=4?s=100" width="100px;" alt="Kalle Westerling"/><br /><sub><b>Kalle Westerling</b></sub></a><br /><a href="https://github.com/Living-with-machines/MapReader/commits?author=kallewesterling" title="Code">💻</a> <a href="https://github.com/Living-with-machines/MapReader/commits?author=kallewesterling" title="Documentation">📖</a> <a href="#maintenance-kallewesterling" title="Maintenance">🚧</a> <a href="https://github.com/Living-with-machines/MapReader/pulls?q=is%3Apr+reviewed-by%3Akallewesterling" title="Reviewed Pull Requests">👀</a> <a href="#talk-kallewesterling" title="Talks">📢</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://maps.nls.uk"><img src="https://avatars.githubusercontent.com/u/3666702?v=4?s=100" width="100px;" alt="Chris Fleet"/><br /><sub><b>Chris Fleet</b></sub></a><br /><a href="#data-ChrisFleet" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kasparvonbeelen"><img src="https://avatars.githubusercontent.com/u/11618160?v=4?s=100" width="100px;" alt="Kaspar Beelen"/><br /><sub><b>Kaspar Beelen</b></sub></a><br /><a href="#ideas-kasparvonbeelen" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/Living-with-machines/MapReader/pulls?q=is%3Apr+reviewed-by%3Akasparvonbeelen" title="Reviewed Pull Requests">👀</a> <a href="#research-kasparvonbeelen" title="Research">🔬</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/andrewphilipsmith"><img src="https://avatars.githubusercontent.com/u/5346065?v=4?s=100" width="100px;" alt="Andy Smith"/><br /><sub><b>Andy Smith</b></sub></a><br /><a href="https://github.com/Living-with-machines/MapReader/commits?author=andrewphilipsmith" title="Code">💻</a> <a href="https://github.com/Living-with-machines/MapReader/commits?author=andrewphilipsmith" title="Documentation">📖</a> <a href="#mentoring-andrewphilipsmith" title="Mentoring">🧑‍🏫</a> <a href="https://github.com/Living-with-machines/MapReader/pulls?q=is%3Apr+reviewed-by%3Aandrewphilipsmith" title="Reviewed Pull Requests">👀</a></td>
      </tr>
    </tbody>
  </table>
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->


pkgId: 27a945b3c0561baaa962f2a7f3bf66c52b999aae9000b61c36f2451e7062a982
name: python-maps4fs-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for maps4fs
url: https://github.com/iwatkot/maps4fs
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maps4fs-1.0.6-1.src.rpm
location_href: Packages/python-maps4fs-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center" markdown>
  <a href="https://discord.gg/Sj5QKKyE42">
  <img src="https://github.com/user-attachments/assets/37043333-d6ef-4ca3-9f3c-81323d9d0b71">
  </a>

  <p align="center">
    <a href="#Quick-Start">Quick Start</a> •
    <a href="#Overview">Overview</a> •
    <a href="docs/step_by_step.md">Create a map in 10 steps</a> •
    <a href="#How-To-Run">How-To-Run</a><br>
    <a href="docs/FAQ.md">FAQ</a> •
    <a href="docs/map_structure.md">Map Structure</a> •
    <a href="#Modder-Toolbox">Modder Toolbox</a><br>
    <a href="#Supported-objects">Supported objects</a> •
    <a href="#Generation-info">Generation info</a> •
    <a href="#Texture-schema">Texture schema</a> •
    <a href="#Background-terrain">Background terrain</a> •
    <a href="#Overview-image">Overview image</a><br>
    <a href="#DDS-conversion">DDS conversion</a> •
    <a href="#For-advanced-users">For advanced users</a> •
    <a href="#Resources">Resources</a> •
    <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
  </p>


  [![Join Discord](https://img.shields.io/badge/join-discord-blue)](https://discord.gg/Sj5QKKyE42)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/releases)
  [![PyPI - Version](https://img.shields.io/pypi/v/maps4fs)](https://pypi.org/project/maps4fs)
  [![Docker Pulls](https://img.shields.io/docker/pulls/iwatkot/maps4fs)](https://hub.docker.com/repository/docker/iwatkot/maps4fs/general)
  [![GitHub issues](https://img.shields.io/github/issues/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/issues)
  [![Maintainability](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/maintainability)](https://codeclimate.com/github/iwatkot/maps4fs/maintainability)<br>
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/maps4fs)](https://pypi.org/project/maps4fs)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Build Status](https://github.com/iwatkot/maps4fs/actions/workflows/checks.yml/badge.svg)](https://github.com/iwatkot/maps4fs/actions)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/test_coverage)](https://codeclimate.com/github/iwatkot/maps4fs/test_coverage)
  [![GitHub Repo stars](https://img.shields.io/github/stars/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/stargazers)

  </div>

  🗺️ Supports 2x2, 4x4, 8x8, 16x16 and any custom size maps<br>
  🌍 Based on real-world data from OpenStreetMap<br>
  🏞️ Generates height using SRTM dataset<br>
  📦 Provides a ready-to-use map template for the Giants Editor<br>
  🚜 Supports Farming Simulator 22 and 25<br>
  🔷 Generates *.obj files for background terrain based on the real-world height map<br>
  📄 Generates scripts to download high-resolution satellite images from [QGIS](https://qgis.org/download/) in one click<br>
  🧰 Modder Toolbox to help you with various tasks 🆕<br>
  🌾 Automatically generates fields 🆕<br>

  <p align="center">
  <img src="https://github.com/user-attachments/assets/cf8f5752-9c69-4018-bead-290f59ba6976"><br>
  🌎 Detailed terrain based on real-world data.<br><br>
  <img src="https://github.com/user-attachments/assets/7f238ab4-9ff4-4c6e-ba07-5796be012baa"><br>
  🛰️ Realistic background terrain objects with satellite images.<br><br>
  <img src="https://github.com/user-attachments/assets/80e5923c-22c7-4dc0-8906-680902511f3a"><br>
  🗒️ True-to-life blueprints for fast and precise modding.<br><br>
  <img width="480" src="https://github.com/user-attachments/assets/1a8802d2-6a3b-4bfa-af2b-7c09478e199b"><br>
  🌾 Field generation with one click.<br><br>
  <img src="https://github.com/user-attachments/assets/cce45575-c917-4a1b-bdc0-6368e32ccdff"><br>
  📏 Almost any possible map sizes.
  </p>

  📹 A complete step-by-step video tutorial is here!
  <a href="https://www.youtube.com/watch?v=Nl_aqXJ5nAk" target="_blank"><img src="https://github.com/user-attachments/assets/4845e030-0e73-47ab-a5a3-430308913060"/></a>
  <i>How to Generate a Map for Farming Simulator 25 and 22 from a real place using maps4FS</i>


  There are several ways to use the tool. You obviously need the **first one**, but you can choose any of the others depending on your needs.<br>

  **Option 1:** Open the [maps4fs](https://maps4fs.streamlit.app) on StreamLit and generate a map template in a few clicks.<br>
  <i>Note, that StreamLit community hosting has some limitations, such as:  <br>
  1. Maximum map size is 4096x4096 meters.  <br>
  2. Advanced settings are disabled.  <br>
  3. Texture dissolving is disabled (they will look worse).  </i><br>

  If you run the application locally, you won't have any of these limitations and will be able to generate maps of any size with any settings you want and nice looking textures.<br>
  So, jump to [Docker version](#option-2-docker-version) to launch the tool with one command and get the full experience.<br>

  ![Basic WebUI](https://github.com/user-attachments/assets/52f499cc-f28a-4da3-abef-0e818abe8dbe)


  **Option 2:** Run the Docker version in your browser. Launch the following command in your terminal:
  ```bash
  docker run -d -p 8501:8501 iwatkot/maps4fs
  ```
  And open [http://localhost:8501](http://localhost:8501) in your browser.<br>
  If you don't know how to use Docker, navigate to the [Docker version](#option-2-docker-version), it's really simple.<br>


  **Option 3:** Python package. Install the package using the following command:
  ```bash
  pip install maps4fs
  ```
  And refer to the [Python package](#option-3-python-package) section to learn how to use it.<br>


  The core idea is coming from the awesome [maps4cim](https://github.com/klamann/maps4cim) project.<br>

  The main goal of this project is to generate map templates, based on real-world data, for the Farming Simulator. It's important to mention that **templates are not maps**. They are just a starting point for creating a map. This tool just uses built-in textures to highlight different types of terrain and buildings with correct shapes and scales and to generate a height map. The rest of the work is up to you. So if you thought that you could just run this tool and get a playable map, then I'm sorry to disappoint you. But if you are a map maker, then this tool will save you a lot of time.<br>
  So, if you're new to map making, here's a quick overview of the process:
  1. Generate a map template using this tool.
  2. Download the Giants Editor.
  3. Open the map template in the Giants Editor.
  4. Now you can start creating your map (adding roads, fields, buildings, etc.).



  The generator also creates multiple previews of the map. Here's the list of them:
  1. General preview - merging all the layers into one image with different colors.
  2. Grayscale DEM preview - a grayscale image of the height map (as it is).
  3. Colored DEM preview - a colored image of the height map (from blue to red). The blue color represents the lowest point, and the red color represents the highest point.

  ![16 km map](https://github.com/user-attachments/assets/82543bcc-1289-479e-bd13-85a8890f0485)<br>
  *Preview of a 16 km map with a 500-meter mountain in the middle of it.*<br>

  Parameters:
  - coordinates: 45.15, 19.71
  - size: 16 x 16 km


  Don't know where to start? Don't worry, just follow this [step-by-step guide](docs/step_by_step.md) to create your first map in 10 simple steps.<br>




  🟢 Recommended for all users.
  🛠️ Don't need to install anything.
  🗺️ Supported map sizes: 2x2, 4x4 km.
  ⚙️ Advanced settings: disabled.
  🖼️ Texture dissolving: disabled.
  Using the [StreamLit](https://maps4fs.streamlit.app) version of the tool is the easiest way to generate a map template. Just open the link and follow the instructions.
  Note: due to CPU and RAM limitations of the hosting, the generation may take some time. If you need faster processing, use the [Docker version](#option-2-docker-version).<br>

  Using it is easy and doesn't require any guides. Enjoy!


  🟠 Recommended for users who want bigger maps, fast generation, nice-looking textures, and advanced settings.
  🛠️ Launch with one single command.
  🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.
  ⚙️ Advanced settings: enabled.
  🖼️ Texture dissolving: enabled.
  You can launch the project with minimalistic UI in your browser using Docker. Follow these steps:

  1. Install [Docker](https://docs.docker.com/get-docker/) for your OS.
  2. Run the following command in your terminal:
  ```bash
  docker run -d -p 8501:8501 iwatkot/maps4fs
  ```
  3. Open your browser and go to [http://localhost:8501](http://localhost:8501).
  4. Fill in the required fields and click on the `Generate` button.
  5. When the map is generated click on the `Download` button to get the map.


  🔴 Recommended for developers.
  🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.
  ⚙️ Advanced settings: enabled.
  🖼️ Texture dissolving: enabled.
  You can use the Python package to generate maps. Follow these steps:

  1. Install the package from PyPI:
  ```bash
  pip install maps4fs
  ```
  2. Import the Game class and create an instance of it:
  ```python
  import maps4fs as mfs

  game = mfs.Game.from_code("FS25")
  ```
  In this case, the library will use the default templates, which should be present in the `data` directory, which should be placed in the current working directory.<br>
  Structure example:<br>

  ```text
  📁 data
   ┣ 📄 fs22-map-template.zip
   ┗ 📄 fs22-texture-schema.json
  ```

  So it's recommended to download the `data` directory from the repository and place it in the root of your project.<br>

  3. Create an instance of the Map class:
  ```python
  import maps4fs as mfs

  map = mfs.Map(
    game,
    (52.5200, 13.4050),  # Latitude and longitude of the map center.
    height=1024,  # The height of the map in meters.
    width=1024,  # The width of the map in meters.
    map_directory="path/to/your/map/directory",  # The directory where the map will be saved.
  )
  ```

  4. Generate the map:
  The `generate` method returns a generator, which yields the active component of the map. You can use it to track the progress of the generation process.
  ```python
  for active_component in map.generate():
      print(active_component)
  ```

  The map will be saved in the `map_directory` directory.


  The tool now has a Modder Toolbox, which is a set of tools to help you with various tasks. You can open the toolbox by switching to the `🧰 Modder Toolbox` tab in the StreamLit app.<br>

  ![Modder Toolbox](https://github.com/user-attachments/assets/dffb252f-f5c0-4021-9d45-31e5bccc0d9b)


  Tools are divided into categories, which are listed below.

  - **GeoTIFF windowing** - allows you to upload your GeoTIFF file and select the region of interest to extract it from the image. It's useful when you have high-resolution DEM data and want to create a height map using it.


  - **Convert image to obj model** - allows you to convert the image to the obj model. You can use this tool to create the background terrain for your map. It can be extremely useful if you have access to the sources of high-resolution DEM data and want to create the background terrain using it.


  The project is based on the [OpenStreetMap](https://www.openstreetmap.org/) data. So, refer to [this page](https://wiki.openstreetmap.org/wiki/Map_Features) to understand the list below.
  - "building": True
  - "highway": ["motorway", "trunk", "primary"]
  - "highway": ["secondary", "tertiary", "road", "service"]
  - "highway": ["unclassified", "residential", "track"]
  - "natural": ["grassland", "scrub"]
  - "landuse": "farmland"
  - "natural": ["water"]
  - "waterway": True
  - "natural": ["wood", "tree_row"]
  - "railway": True

  The list will be updated as the project develops.


  The script will generate the `generation_info.json` file in the `output` folder. It is split into different sections, which represent the components of the map generator. You may need this information to use some other tools and services to obtain additional data for your map.<br>

  List of components:
  - `Config` - this component handles the `map.xml` file, where the basic description of the map is stored.
  - `Texture` -  this component describes the textures, that were used to generate the map.
  - `DEM` - this component describes the Digital Elevation Model (the one which creates terrain on your map), which was used to generate the height map and related to the `dem.png` file.
  - `I3d` - this component describes the i3d file, where some specific attributes properties, and paths to the files are stored.
  - `Background` - this component describes the 8 tiles, that surround the map.

  Below you'll find descriptions of the components and the fields that they contain.<br>
  ℹ️ If there's no information about the component, it means that at the moment it does not store any data in the `generation_info.json` file.


  Example of the `Config` component:
  ```json
  "Config": {
      "Overview": {
          "epsg3857_string": "2249906.6679576184,2255734.9033189337,5663700.389039194,5669528.6247056825 [EPSG:3857]",
          "south": 45.304132173367165,
          "west": 45.267296012425376,
          "north": 20.263611405732693,
          "east": 20.211255476687537,
          "height": 4096,
          "width": 4096
      }
  },
  ```
  The `Overview` section contains information to create an overview image, which represents the in-game map. You can use the `epsg3857_string` to obtain the satellite images in the QGIS. So this section describes the region of the map plus the borders. Usually, it's exactly 2X the size of the map.<br>
  And here's the list of the fields:
  - `"epsg3857_string"` - the string representation of the bounding box in the EPSG:3857 projection, it is required to obtain the satellite images in the QGIS,<br>
  - `"south"` - the southern border of overview region,<br>
  - `"west"` - the western border of overview region,<br>
  - `"north"` - the northern border of overview region,<br>
  - `"east"` - the eastern border of overview region,<br>
  - `"height"` - the height of the overview region in meters (2X the size of the map),<br>
  - `"width"` - the width of the overview region in meters,<br>



  Example of the `Texture` component:
  ```json
  "Texture": {
      "coordinates": [
          45.28571409289627,
          20.237433441210115
      ],
      "bbox": [
          45.29492313313172,
          45.27650505266082,
          20.250522423471406,
          20.224344458948824
      ],
      "map_height": 2048,
      "map_width": 2048,
      "minimum_x": 439161.2439774908,
      "minimum_y": 5013940.540089059,
      "maximum_x": 441233.5397821935,
      "maximum_y": 5016006.074349126,
  },
  ```

  And here's the list of the fields:

  - `"coordinates"` - the coordinates of the map center which you entered,<br>
  - `"bbox"` - the bounding box of the map in lat and lon,<br>
  - `"map_height"` - the height of the map in meters (this one is from the user input, e.g. 2048 and so on),<br>
  - `"map_width"` - the width of the map in meters (same as above),<br>
  - `"minimum_x"` - the minimum x coordinate of the map (UTM projection),<br>
  - `"minimum_y"` - the minimum y coordinate of the map (UTM projection),<br>
  - `"maximum_x"` - the maximum x coordinate of the map (UTM projection),<br>
  - `"maximum_y"` - the maximum y coordinate of the map (UTM projection),



  The background component consists of the 8 tiles, each one representing the tile, that surrounds the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on.<br>
  Example of the `Background` component:

  ```json
  "Background": {
  "N": {
      "center_latitude": 45.30414170952092,
      "center_longitude": 20.237433441210115,
      "epsg3857_string": "2251363.25324853,2254278.318028022,5668072.719985372,5670987.784803056 [EPSG:3857]",
      "height": 2048,
      "width": 2048,
      "north": 45.31335074975637,
      "south": 45.29493266928547,
      "east": 20.250526677438195,
      "west": 20.224340204982035
  },
  }
  ```

  And here's the list of the fields:
  - `"center_latitude"` - the latitude of the center of the tile,<br>
  - `"center_longitude"` - the longitude of the center of the tile,<br>
  - `"epsg3857_string"` - the string representation of the bounding box in the EPSG:3857 projection, it is required to obtain the satellite images in the QGIS,<br>
  - `"height"` - the height of the tile in meters,<br>
  - `"width"` - the width of the tile in meters,<br>
  - `"north"` - the northern border of the tile,<br>
  - `"south"` - the southern border of the tile,<br>
  - `"east"` - the eastern border of the tile,<br>
  - `"west"` - the western border of the tile,<br>


  maps4fs uses a simple JSON file to define the texture schema. For each ofthe  supported games, this file has unique entries, but the structure is the same. Here's an example of the schema for Farming Simulator 25:

  ```json
  [
      {
      "name": "forestRockRoots",
      "count": 2,
      "exclude_weight": true
    },
    {
      "name": "grass",
      "count": 2,
      "tags": { "natural": "grassland" },
      "color": [34, 255, 34],
      "priority": 0
    },
    {
      "name": "grassClovers",
      "count": 2
    },
    {
      "name": "grassCut",
      "count": 2
    },
    {
      "name": "grassDirtPatchy",
      "count": 2,
      "tags": { "natural": ["wood", "tree_row"] },
      "width": 2,
      "color": [0, 252, 124]
    }
  ]
  ```
  Let's have a closer look at the fields:
  - `name` - the name of the texture. Just the way the file will be named.
  - `count` - the number of textures of this type. For example, for the **dirtMedium** texture there will be two textures: **dirtMedium01_weight.png** and **dirtMedium02_weight.png**.
  ℹ️ There's one texture that has count `0`, it's the waterPuddle texture from FS22, which is not present in FS25.
  - `tags` - the tags from the OpenStreetMap data. Refer to the section [Supported objects](#supported-objects) to see the list of supported tags. If there are no tags, the texture file will be generated empty and no objects will be placed on it.
  - `width` - the width of the texture in meters. Some of the objects from OSM (roads, for example) are lines, not areas. So, to draw them correctly, the tool needs to know the width of the line.
  - `color` - the color of the texture. It's used only in the preview images and has no effect on the map itself. But remember that previews are crucial for the map-making process, so it's better to set the color to something that represents the texture.
  - `priority` - the priority of the texture for overlapping. Textures with higher priorities will be drawn over the textures with lower priorities.
  ℹ️ The texture with 0 priority considers the base layer, which means that all empty areas will be filled with this texture.
  - `exclude_weight` - this is only used for the forestRockRoots texture from FS25. It just means that this texture has no `weight` postfix, that's all.


  The tool now supports the generation of the background terrain. If you don't know what it is, here's a brief explanation. The background terrain is the world around the map. It's important to create it because if you don't, the map will look like it's floating in the void. The background terrain is a simple plane that can (and should) be textured to look fine.<br>
  So, the tool generates the background terrain in the form of the 8 tiles, which surround the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on. All those tiles will be saved in the `background` directory with corresponding names: `N.obj`, `NE.obj`, `E.obj`, and so on.<br>
  If you don't want to work with separate tiles, the tool also generates the `FULL.obj` file, which includes everything around the map and the map itself. It may be a convenient approach to work with one file, one texture, and then just cut the map from it.<br>

  ![Complete background terrain in Blender](https://github.com/user-attachments/assets/7266b8f1-bfa2-4c14-a740-1c84b1030a66)

  ➡️ *No matter which approach you choose, you still need to adjust the background terrain to connect it to the map without any gaps. But with a single file, it's much easier to do.*

  If you're willing to create a background terrain, you will need Blender, the Blender Exporter Plugins, and the QGIS. You'll find the download links in the [Resources](#resources) section.<br>

  If you're afraid of this task, please don't be. It's really simple and I've prepared detailed step-by-step instructions for you, you'll find them in the separate README files. Here are the steps you need to follow:

  1. [Download high-resolution satellite images](docs/download_satellite_images.md).
  2. [Prepare the i3d files](docs/create_background_terrain.md).
  3. [Import the i3d files to Giants Editor](docs/import_to_giants_editor.md).


  The overview image is an image that is used as an in-game map. No matter what the size of the map, this file is always `4096x4096 pixels`, while the region of your map is `2048x2048 pixels` in the center of this file. The rest of the image is just here for a nice view, but you still may add satellite pictures to this region.<br>

  <img width="400" src="https://github.com/user-attachments/assets/ede9ea81-ef97-4914-9dbf-9761ef1eb7ca">

  Cool image by [@ZenJakey](https://github.com/ZenJakey).

  So, in the same way, you've downloaded the satellite images for the background terrain, you can download them for the overview image. Just use the `epsg3857_string` from the `generation_info.json` file. You'll find the needed string in the `Config` component in the `Overview` section:

  ```json
  "Config": {
      "Overview": {
          "epsg3857_string": "2249906.6679576184,2255734.9033189337,5663700.389039194,5669528.6247056825 [EPSG:3857]",
      }
  },
  ```

  After that, you need to resize the image to 4096x4096 pixels and convert it to the `.dds` format.


  The `.dds` format is the format used in the Farming Simulator for the textures, icons, overview, and preview images. There a plenty of options to convert the images to the `.dds` format, you can just google something like `png to dds`, and the first link probably will help you with it.<br>

  List of the important DDS files:
  - `icon.dds` - 256x256 pixels, the icon of the map,
  - `preview.dds` - 2048x2048 pixels, the preview image of the map on the loading screen,
  - `mapsUS/overview.dds` - 4096x4096 pixels, the overview image of the map (in-game map)


  The tool supports the custom size of the map. To use this feature select `Custom` in the `Map size` dropdown and enter the desired size. The tool will generate a map with the size you entered.<br>

  ⛔️ Do not use this feature, if you don't know what you're doing. In most cases, the Giants Editor will just crash on opening the file, because you need to enter specific values for the map size.<br><br>

  ![Advanced settings](https://github.com/user-attachments/assets/e7406adf-6b82-41a0-838a-13dd8877bebf)

  You can also apply some advanced settings to the map generation process. Note that they're ADVANCED, so you don't need to use them if you're not sure what they do.<br>

  Here's the list of the advanced settings:

  - DEM multiplier: the height of the map is multiplied by this value. So the DEM map is just a 16-bit grayscale image, which means that the maximum available value there is 65535, while the actual difference between the deepest and the highest point on Earth is about 20 km. Just note that this setting mostly does not matter, because you can always adjust it in the Giants Editor, learn more about the DEM file and the heightScale parameter in [docs](docs/dem.md). By default, it's set to 1.

  - DEM Blur radius: the radius of the Gaussian blur filter applied to the DEM map. By default, it's set to 21. This filter just makes the DEM map smoother, so the height transitions will be more natural. You can set it to 1 to disable the filter, but it will result in a Minecraft-like map.

  - DEM Plateau height: this value will be added to each pixel of the DEM image, making it "higher". It's useful when you want to add some negative heights on the map, that appear to be in a "low" place. By default, it's set to 0.


  In this section, you'll find a list of the resources that you need to create a map for the Farming Simulator.<br>
  To create a basic map, you only need the Giants Editor. But if you want to create a background terrain - the world around the map, so it won't look like it's floating in the void - you also need Blender and the Blender Exporter Plugins. To create realistic textures for the background terrain, the QGIS is required to obtain high-resolution satellite images.<br>

  1. [Giants Editor](https://gdn.giants-software.com/downloads.php) - the official tool for creating maps for the Farming Simulator.
  2. [Blender](https://www.blender.org/download/) - the open-source 3D modeling software that you can use to create models for the Farming Simulator.
  3. [Blender Exporter Plugins](https://gdn.giants-software.com/downloads.php) - the official plugins for exporting models from Blender to i3d format (the format used in the Farming Simulator).
  4. [QGIS](https://qgis.org/download/) - the open-source GIS software that you can use to obtain high-resolution satellite images for your map.
  5. [CompressPngCom](https://www.compresspng.com/) - the online tool to compress the PNG images. May be useful to reduce the size of the satellite images.
  6. [AnyConv](https://anyconv.com/png-to-dds-converter/) - the online tool to convert the PNG images to the DDS format. You'll need this format for the textures, icons, overview, and preview images.


  ➡️ Please, before creating an issue or asking some questions, check the [FAQ](docs/FAQ.md) section.<br>
  If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot) or on Discord: `iwatkot`.


pkgId: 023cc799ec27cc993115cc0dfee6c3ed9f7ac153b4c9e72a84d6a5de988c1a08
name: python-maps4fs-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for maps4fs
url: https://github.com/iwatkot/maps4fs
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maps4fs-1.1.2-1.src.rpm
location_href: Packages/python-maps4fs-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center" markdown>
  <a href="https://discord.gg/Sj5QKKyE42">
  <img src="https://github.com/user-attachments/assets/37043333-d6ef-4ca3-9f3c-81323d9d0b71">
  </a>

  <p align="center">
    <a href="#Quick-Start">Quick Start</a> •
    <a href="#Overview">Overview</a> •
    <a href="docs/step_by_step.md">Create a map in 10 steps</a> •
    <a href="#How-To-Run">How-To-Run</a><br>
    <a href="docs/FAQ.md">FAQ</a> •
    <a href="docs/map_structure.md">Map Structure</a> •
    <a href="#Modder-Toolbox">Modder Toolbox</a><br>
    <a href="#Supported-objects">Supported objects</a> •
    <a href="#Generation-info">Generation info</a> •
    <a href="#Texture-schema">Texture schema</a> •
    <a href="#Background-terrain">Background terrain</a> •
    <a href="#Overview-image">Overview image</a><br>
    <a href="#DDS-conversion">DDS conversion</a> •
    <a href="#For-advanced-users">For advanced users</a> •
    <a href="#Resources">Resources</a> •
    <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
  </p>


  [![Join Discord](https://img.shields.io/badge/join-discord-blue)](https://discord.gg/Sj5QKKyE42)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/releases)
  [![PyPI - Version](https://img.shields.io/pypi/v/maps4fs)](https://pypi.org/project/maps4fs)
  [![Docker Pulls](https://img.shields.io/docker/pulls/iwatkot/maps4fs)](https://hub.docker.com/repository/docker/iwatkot/maps4fs/general)
  [![GitHub issues](https://img.shields.io/github/issues/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/issues)
  [![Maintainability](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/maintainability)](https://codeclimate.com/github/iwatkot/maps4fs/maintainability)<br>
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/maps4fs)](https://pypi.org/project/maps4fs)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Build Status](https://github.com/iwatkot/maps4fs/actions/workflows/checks.yml/badge.svg)](https://github.com/iwatkot/maps4fs/actions)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/test_coverage)](https://codeclimate.com/github/iwatkot/maps4fs/test_coverage)
  [![GitHub Repo stars](https://img.shields.io/github/stars/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/stargazers)

  </div>

  🗺️ Supports 2x2, 4x4, 8x8, 16x16 and any custom size maps<br>
  🔄 Support map rotation 🆕<br>
  🌾 Automatically generates fields 🆕<br>
  🌽 Automatically generates farmlands 🆕<br>
  🌍 Based on real-world data from OpenStreetMap<br>
  🏞️ Generates height map using SRTM dataset<br>
  📦 Provides a ready-to-use map template for the Giants Editor<br>
  🚜 Supports Farming Simulator 22 and 25<br>
  🔷 Generates *.obj files for background terrain based on the real-world height map<br>
  📄 Generates scripts to download high-resolution satellite images from [QGIS](https://qgis.org/download/) in one click<br>
  📕 Detailed [documentation](/docs) and tutorials <br>
  🧰 Modder Toolbox to help you with various tasks <br>

  <p align="center">
  <img src="https://github.com/user-attachments/assets/cf8f5752-9c69-4018-bead-290f59ba6976"><br>
  🌎 Detailed terrain based on real-world data.<br><br>
  <img src="https://github.com/user-attachments/assets/7f238ab4-9ff4-4c6e-ba07-5796be012baa"><br>
  🛰️ Realistic background terrain objects with satellite images.<br><br>
  <img src="https://github.com/user-attachments/assets/80e5923c-22c7-4dc0-8906-680902511f3a"><br>
  🗒️ True-to-life blueprints for fast and precise modding.<br><br>
  <img width="480" src="https://github.com/user-attachments/assets/1a8802d2-6a3b-4bfa-af2b-7c09478e199b"><br>
  🌾 Field generation with one click.<br><br>
  <img width="480" src="https://github.com/user-attachments/assets/4d1fa879-5d60-438b-a84e-16883bcef0ec"><br>
  🌽 Automatic farmlands generation based on the fields.<br><br>
  <img src="https://github.com/user-attachments/assets/cce45575-c917-4a1b-bdc0-6368e32ccdff"><br>
  📏 Almost any possible map sizes.
  </p>

  📹 A complete step-by-step video tutorial is here!
  <a href="https://www.youtube.com/watch?v=Nl_aqXJ5nAk" target="_blank"><img src="https://github.com/user-attachments/assets/4845e030-0e73-47ab-a5a3-430308913060"/></a>
  <p align="center"><i>How to Generate a Map for Farming Simulator 25 and 22 from a real place using maps4FS.</i></p>


  There are several ways to use the tool. You obviously need the **first one**, but you can choose any of the others depending on your needs.<br>

  **Option 1:** Open the [maps4fs](https://maps4fs.streamlit.app) on StreamLit and generate a map template in a few clicks.<br>
  <i>Note, that StreamLit community hosting has some limitations, such as:  <br>
  1. Maximum map size is 4096x4096 meters.  <br>
  2. Advanced settings are disabled.  <br>
  3. Texture dissolving is disabled (they will look worse).  </i><br>

  If you run the application locally, you won't have any of these limitations and will be able to generate maps of any size with any settings you want and nice looking textures.<br>
  So, jump to [Docker version](#option-2-docker-version) to launch the tool with one command and get the full experience.<br>

  ![Basic WebUI](https://github.com/user-attachments/assets/52f499cc-f28a-4da3-abef-0e818abe8dbe)


  **Option 2:** Run the Docker version in your browser. Launch the following command in your terminal:
  ```bash
  docker run -d -p 8501:8501 iwatkot/maps4fs
  ```
  And open [http://localhost:8501](http://localhost:8501) in your browser.<br>
  If you don't know how to use Docker, navigate to the [Docker version](#option-2-docker-version), it's really simple.<br>


  **Option 3:** Python package. Install the package using the following command:
  ```bash
  pip install maps4fs
  ```
  And refer to the [Python package](#option-3-python-package) section to learn how to use it.<br>


  The core idea is coming from the awesome [maps4cim](https://github.com/klamann/maps4cim) project.<br>

  The main goal of this project is to generate map templates, based on real-world data, for the Farming Simulator. It's important to mention that **templates are not maps**. They are just a starting point for creating a map. This tool just uses built-in textures to highlight different types of terrain and buildings with correct shapes and scales and to generate a height map. The rest of the work is up to you. So if you thought that you could just run this tool and get a playable map, then I'm sorry to disappoint you. But if you are a map maker, then this tool will save you a lot of time.<br>
  So, if you're new to map making, here's a quick overview of the process:
  1. Generate a map template using this tool.
  2. Download the Giants Editor.
  3. Open the map template in the Giants Editor.
  4. Now you can start creating your map (adding roads, fields, buildings, etc.).



  The generator also creates multiple previews of the map. Here's the list of them:
  1. General preview - merging all the layers into one image with different colors.
  2. Grayscale DEM preview - a grayscale image of the height map (as it is).
  3. Colored DEM preview - a colored image of the height map (from blue to red). The blue color represents the lowest point, and the red color represents the highest point.

  ![16 km map](https://github.com/user-attachments/assets/82543bcc-1289-479e-bd13-85a8890f0485)<br>
  *Preview of a 16 km map with a 500-meter mountain in the middle of it.*<br>

  Parameters:
  - coordinates: 45.15, 19.71
  - size: 16 x 16 km


  Don't know where to start? Don't worry, just follow this [step-by-step guide](docs/step_by_step.md) to create your first map in 10 simple steps.<br>




  🟢 Recommended for all users.
  🛠️ Don't need to install anything.
  🗺️ Supported map sizes: 2x2, 4x4 km.
  ⚙️ Advanced settings: disabled.
  🖼️ Texture dissolving: disabled.
  Using the [StreamLit](https://maps4fs.streamlit.app) version of the tool is the easiest way to generate a map template. Just open the link and follow the instructions.
  Note: due to CPU and RAM limitations of the hosting, the generation may take some time. If you need faster processing, use the [Docker version](#option-2-docker-version).<br>

  Using it is easy and doesn't require any guides. Enjoy!


  🟠 Recommended for users who want bigger maps, fast generation, nice-looking textures, and advanced settings.
  🛠️ Launch with one single command.
  🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.
  ⚙️ Advanced settings: enabled.
  🖼️ Texture dissolving: enabled.
  You can launch the project with minimalistic UI in your browser using Docker. Follow these steps:

  1. Install [Docker](https://docs.docker.com/get-docker/) for your OS.
  2. Run the following command in your terminal:
  ```bash
  docker run -d -p 8501:8501 iwatkot/maps4fs
  ```
  3. Open your browser and go to [http://localhost:8501](http://localhost:8501).
  4. Fill in the required fields and click on the `Generate` button.
  5. When the map is generated click on the `Download` button to get the map.


  🔴 Recommended for developers.
  🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.
  ⚙️ Advanced settings: enabled.
  🖼️ Texture dissolving: enabled.
  You can use the Python package to generate maps. Follow these steps:

  1. Install the package from PyPI:
  ```bash
  pip install maps4fs
  ```
  2. Import the Game class and create an instance of it:
  ```python
  import maps4fs as mfs

  game = mfs.Game.from_code("FS25")
  ```
  In this case, the library will use the default templates, which should be present in the `data` directory, which should be placed in the current working directory.<br>
  Structure example:<br>

  ```text
  📁 data
   ┣ 📄 fs22-map-template.zip
   ┗ 📄 fs22-texture-schema.json
  ```

  So it's recommended to download the `data` directory from the repository and place it in the root of your project.<br>

  3. Create an instance of the Map class:
  ```python
  import maps4fs as mfs

  map = mfs.Map(
    game,
    (52.5200, 13.4050),  # Latitude and longitude of the map center.
    height=1024,  # The height of the map in meters.
    width=1024,  # The width of the map in meters.
    map_directory="path/to/your/map/directory",  # The directory where the map will be saved.
  )
  ```

  4. Generate the map:
  The `generate` method returns a generator, which yields the active component of the map. You can use it to track the progress of the generation process.
  ```python
  for active_component in map.generate():
      print(active_component)
  ```

  The map will be saved in the `map_directory` directory.


  The tool now has a Modder Toolbox, which is a set of tools to help you with various tasks. You can open the toolbox by switching to the `🧰 Modder Toolbox` tab in the StreamLit app.<br>

  ![Modder Toolbox](https://github.com/user-attachments/assets/dffb252f-f5c0-4021-9d45-31e5bccc0d9b)


  Tools are divided into categories, which are listed below.

  - **GeoTIFF windowing** - allows you to upload your GeoTIFF file and select the region of interest to extract it from the image. It's useful when you have high-resolution DEM data and want to create a height map using it.


  - **Convert image to obj model** - allows you to convert the image to the obj model. You can use this tool to create the background terrain for your map. It can be extremely useful if you have access to the sources of high-resolution DEM data and want to create the background terrain using it.


  The project is based on the [OpenStreetMap](https://www.openstreetmap.org/) data. So, refer to [this page](https://wiki.openstreetmap.org/wiki/Map_Features) to understand the list below.
  - "building": True
  - "highway": ["motorway", "trunk", "primary"]
  - "highway": ["secondary", "tertiary", "road", "service"]
  - "highway": ["unclassified", "residential", "track"]
  - "natural": ["grassland", "scrub"]
  - "landuse": "farmland"
  - "natural": ["water"]
  - "waterway": True
  - "natural": ["wood", "tree_row"]
  - "railway": True

  The list will be updated as the project develops.


  The script will generate the `generation_info.json` file in the `output` folder. It is split into different sections, which represent the components of the map generator. You may need this information to use some other tools and services to obtain additional data for your map.<br>

  List of components:
  - `Config` - this component handles the `map.xml` file, where the basic description of the map is stored.
  - `Texture` -  this component describes the textures, that were used to generate the map.
  - `DEM` - this component describes the Digital Elevation Model (the one which creates terrain on your map), which was used to generate the height map and related to the `dem.png` file.
  - `I3d` - this component describes the i3d file, where some specific attributes properties, and paths to the files are stored.
  - `Background` - this component describes the 8 tiles, that surround the map.

  Below you'll find descriptions of the components and the fields that they contain.<br>
  ℹ️ If there's no information about the component, it means that at the moment it does not store any data in the `generation_info.json` file.


  Example of the `Config` component:
  ```json
  "Config": {
      "Overview": {
          "epsg3857_string": "2249906.6679576184,2255734.9033189337,5663700.389039194,5669528.6247056825 [EPSG:3857]",
          "south": 45.304132173367165,
          "west": 45.267296012425376,
          "north": 20.263611405732693,
          "east": 20.211255476687537,
          "height": 4096,
          "width": 4096
      }
  },
  ```
  The `Overview` section contains information to create an overview image, which represents the in-game map. You can use the `epsg3857_string` to obtain the satellite images in the QGIS. So this section describes the region of the map plus the borders. Usually, it's exactly 2X the size of the map.<br>
  And here's the list of the fields:
  - `"epsg3857_string"` - the string representation of the bounding box in the EPSG:3857 projection, it is required to obtain the satellite images in the QGIS,<br>
  - `"south"` - the southern border of overview region,<br>
  - `"west"` - the western border of overview region,<br>
  - `"north"` - the northern border of overview region,<br>
  - `"east"` - the eastern border of overview region,<br>
  - `"height"` - the height of the overview region in meters (2X the size of the map),<br>
  - `"width"` - the width of the overview region in meters,<br>



  Example of the `Texture` component:
  ```json
  "Texture": {
      "coordinates": [
          45.28571409289627,
          20.237433441210115
      ],
      "bbox": [
          45.29492313313172,
          45.27650505266082,
          20.250522423471406,
          20.224344458948824
      ],
      "map_height": 2048,
      "map_width": 2048,
      "minimum_x": 439161.2439774908,
      "minimum_y": 5013940.540089059,
      "maximum_x": 441233.5397821935,
      "maximum_y": 5016006.074349126,
  },
  ```

  And here's the list of the fields:

  - `"coordinates"` - the coordinates of the map center which you entered,<br>
  - `"bbox"` - the bounding box of the map in lat and lon,<br>
  - `"map_height"` - the height of the map in meters (this one is from the user input, e.g. 2048 and so on),<br>
  - `"map_width"` - the width of the map in meters (same as above),<br>
  - `"minimum_x"` - the minimum x coordinate of the map (UTM projection),<br>
  - `"minimum_y"` - the minimum y coordinate of the map (UTM projection),<br>
  - `"maximum_x"` - the maximum x coordinate of the map (UTM projection),<br>
  - `"maximum_y"` - the maximum y coordinate of the map (UTM projection),



  The background component consists of the 8 tiles, each one representing the tile, that surrounds the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on.<br>
  Example of the `Background` component:

  ```json
  "Background": {
  "N": {
      "center_latitude": 45.30414170952092,
      "center_longitude": 20.237433441210115,
      "epsg3857_string": "2251363.25324853,2254278.318028022,5668072.719985372,5670987.784803056 [EPSG:3857]",
      "height": 2048,
      "width": 2048,
      "north": 45.31335074975637,
      "south": 45.29493266928547,
      "east": 20.250526677438195,
      "west": 20.224340204982035
  },
  }
  ```

  And here's the list of the fields:
  - `"center_latitude"` - the latitude of the center of the tile,<br>
  - `"center_longitude"` - the longitude of the center of the tile,<br>
  - `"epsg3857_string"` - the string representation of the bounding box in the EPSG:3857 projection, it is required to obtain the satellite images in the QGIS,<br>
  - `"height"` - the height of the tile in meters,<br>
  - `"width"` - the width of the tile in meters,<br>
  - `"north"` - the northern border of the tile,<br>
  - `"south"` - the southern border of the tile,<br>
  - `"east"` - the eastern border of the tile,<br>
  - `"west"` - the western border of the tile,<br>


  maps4fs uses a simple JSON file to define the texture schema. For each ofthe  supported games, this file has unique entries, but the structure is the same. Here's an example of the schema for Farming Simulator 25:

  ```json
  [
      {
      "name": "forestRockRoots",
      "count": 2,
      "exclude_weight": true
    },
    {
      "name": "grass",
      "count": 2,
      "tags": { "natural": "grassland" },
      "color": [34, 255, 34],
      "priority": 0
    },
    {
      "name": "grassClovers",
      "count": 2
    },
    {
      "name": "grassCut",
      "count": 2
    },
    {
      "name": "grassDirtPatchy",
      "count": 2,
      "tags": { "natural": ["wood", "tree_row"] },
      "width": 2,
      "color": [0, 252, 124]
    }
  ]
  ```
  Let's have a closer look at the fields:
  - `name` - the name of the texture. Just the way the file will be named.
  - `count` - the number of textures of this type. For example, for the **dirtMedium** texture there will be two textures: **dirtMedium01_weight.png** and **dirtMedium02_weight.png**.
  ℹ️ There's one texture that has count `0`, it's the waterPuddle texture from FS22, which is not present in FS25.
  - `tags` - the tags from the OpenStreetMap data. Refer to the section [Supported objects](#supported-objects) to see the list of supported tags. If there are no tags, the texture file will be generated empty and no objects will be placed on it.
  - `width` - the width of the texture in meters. Some of the objects from OSM (roads, for example) are lines, not areas. So, to draw them correctly, the tool needs to know the width of the line.
  - `color` - the color of the texture. It's used only in the preview images and has no effect on the map itself. But remember that previews are crucial for the map-making process, so it's better to set the color to something that represents the texture.
  - `priority` - the priority of the texture for overlapping. Textures with higher priorities will be drawn over the textures with lower priorities.
  ℹ️ The texture with 0 priority considers the base layer, which means that all empty areas will be filled with this texture.
  - `exclude_weight` - this is only used for the forestRockRoots texture from FS25. It just means that this texture has no `weight` postfix, that's all.


  The tool now supports the generation of the background terrain. If you don't know what it is, here's a brief explanation. The background terrain is the world around the map. It's important to create it because if you don't, the map will look like it's floating in the void. The background terrain is a simple plane that can (and should) be textured to look fine.<br>
  So, the tool generates the background terrain in the form of the 8 tiles, which surround the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on. All those tiles will be saved in the `background` directory with corresponding names: `N.obj`, `NE.obj`, `E.obj`, and so on.<br>
  If you don't want to work with separate tiles, the tool also generates the `FULL.obj` file, which includes everything around the map and the map itself. It may be a convenient approach to work with one file, one texture, and then just cut the map from it.<br>

  ![Complete background terrain in Blender](https://github.com/user-attachments/assets/7266b8f1-bfa2-4c14-a740-1c84b1030a66)

  ➡️ *No matter which approach you choose, you still need to adjust the background terrain to connect it to the map without any gaps. But with a single file, it's much easier to do.*

  If you're willing to create a background terrain, you will need Blender, the Blender Exporter Plugins, and the QGIS. You'll find the download links in the [Resources](#resources) section.<br>

  If you're afraid of this task, please don't be. It's really simple and I've prepared detailed step-by-step instructions for you, you'll find them in the separate README files. Here are the steps you need to follow:

  1. [Download high-resolution satellite images](docs/download_satellite_images.md).
  2. [Prepare the i3d files](docs/create_background_terrain.md).
  3. [Import the i3d files to Giants Editor](docs/import_to_giants_editor.md).


  The overview image is an image that is used as an in-game map. No matter what the size of the map, this file is always `4096x4096 pixels`, while the region of your map is `2048x2048 pixels` in the center of this file. The rest of the image is just here for a nice view, but you still may add satellite pictures to this region.<br>

  <img width="400" src="https://github.com/user-attachments/assets/ede9ea81-ef97-4914-9dbf-9761ef1eb7ca">

  Cool image by [@ZenJakey](https://github.com/ZenJakey).

  So, in the same way, you've downloaded the satellite images for the background terrain, you can download them for the overview image. Just use the `epsg3857_string` from the `generation_info.json` file. You'll find the needed string in the `Config` component in the `Overview` section:

  ```json
  "Config": {
      "Overview": {
          "epsg3857_string": "2249906.6679576184,2255734.9033189337,5663700.389039194,5669528.6247056825 [EPSG:3857]",
      }
  },
  ```

  After that, you need to resize the image to 4096x4096 pixels and convert it to the `.dds` format.


  The `.dds` format is the format used in the Farming Simulator for the textures, icons, overview, and preview images. There a plenty of options to convert the images to the `.dds` format, you can just google something like `png to dds`, and the first link probably will help you with it.<br>

  List of the important DDS files:
  - `icon.dds` - 256x256 pixels, the icon of the map,
  - `preview.dds` - 2048x2048 pixels, the preview image of the map on the loading screen,
  - `mapsUS/overview.dds` - 4096x4096 pixels, the overview image of the map (in-game map)


  The tool supports the custom size of the map. To use this feature select `Custom` in the `Map size` dropdown and enter the desired size. The tool will generate a map with the size you entered.<br>

  ⛔️ Do not use this feature, if you don't know what you're doing. In most cases, the Giants Editor will just crash on opening the file, because you need to enter specific values for the map size.<br><br>

  ![Advanced settings](https://github.com/user-attachments/assets/9e8e178a-58d9-4aa6-aefd-4ed53408701d)

  You can also apply some advanced settings to the map generation process. Note that they're ADVANCED, so you don't need to use them if you're not sure what they do.<br>



  - Multiplier: the height of the map is multiplied by this value. So the DEM map is just a 16-bit grayscale image, which means that the maximum available value there is 65535, while the actual difference between the deepest and the highest point on Earth is about 20 km. Just note that this setting mostly does not matter, because you can always adjust it in the Giants Editor, learn more about the DEM file and the heightScale parameter in [docs](docs/dem.md). By default, it's set to 1.

  - Blur radius: the radius of the Gaussian blur filter applied to the DEM map. By default, it's set to 21. This filter just makes the DEM map smoother, so the height transitions will be more natural. You can set it to 1 to disable the filter, but it will result in a Minecraft-like map.

  - Plateau height: this value will be added to each pixel of the DEM image, making it "higher". It's useful when you want to add some negative heights on the map, that appear to be in a "low" place. By default, it's set to 0.



  - Fields padding - this value (in meters) will be applied to each field, making it smaller. It's useful when the fields are too close to each other and you want to make them smaller. By default, it's set to 0.



  - Farmlands margin - this value (in meters) will be applied to each farmland, making it bigger. You can use the value to adjust how much the farmland should be bigger than the actual field. By default, it's set to 3.


  In this section, you'll find a list of the resources that you need to create a map for the Farming Simulator.<br>
  To create a basic map, you only need the Giants Editor. But if you want to create a background terrain - the world around the map, so it won't look like it's floating in the void - you also need Blender and the Blender Exporter Plugins. To create realistic textures for the background terrain, the QGIS is required to obtain high-resolution satellite images.<br>

  1. [Giants Editor](https://gdn.giants-software.com/downloads.php) - the official tool for creating maps for the Farming Simulator.
  2. [Blender](https://www.blender.org/download/) - the open-source 3D modeling software that you can use to create models for the Farming Simulator.
  3. [Blender Exporter Plugins](https://gdn.giants-software.com/downloads.php) - the official plugins for exporting models from Blender to i3d format (the format used in the Farming Simulator).
  4. [QGIS](https://qgis.org/download/) - the open-source GIS software that you can use to obtain high-resolution satellite images for your map.
  5. [CompressPngCom](https://www.compresspng.com/) - the online tool to compress the PNG images. May be useful to reduce the size of the satellite images.
  6. [AnyConv](https://anyconv.com/png-to-dds-converter/) - the online tool to convert the PNG images to the DDS format. You'll need this format for the textures, icons, overview, and preview images.


  ➡️ Please, before creating an issue or asking some questions, check the [FAQ](docs/FAQ.md) section.<br>
  If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot) or on Discord: `iwatkot`.


pkgId: 82c07f1089892ca880279f5f62221ea09a4af971631c6a393d23563768abe604
name: python-mapstorch-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for mapstorch
url: https://github.com/xyin-anl/MapsTorch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mapstorch-0.0.1-1.src.rpm
location_href: Packages/python-mapstorch-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="assets/logo.png" alt="MapsTorch Logo" width="400"/>
  </p>



  MapsTorch is a differentiable modeling package for automating X-ray fluorescence (XRF) analysis. It combines the physics-based [MAPS](https://www.aps.anl.gov/Microscopy/Software-and-Tools-MAPS) model with PyTorch's automatic differentiation framework.

  Key features:

  - Automated parameter optimization for XRF spectrum fitting
  - Automatic element detection and decision support
  - GPU acceleration support for spectrum volume fitting
  - Integration with existing [XRF-Maps](https://github.com/xyin-anl/XRF-Maps) workflows

  See [extended abstract](https://academic.oup.com/mam/article/30/Supplement_1/ozae044.1017/7720325) from M&M 2024.



  Latest development version:

  ```
  pip install git+https://github.com/xyin-anl/MapsTorch.git
  ```

  Latest release version:

  ```
  pip install mapstorch
  ```

  _Optional:_ For GPU acceleration of spectra volume fitting, install PyTorch with CUDA support following https://pytorch.org/get-started/locally/



  MapsTorch works with HDF5 files produced by [XRFMaps](https://github.com/xyin-anl/XRF-Maps). The HDF5 file must contain:

  - Spectra volume data in `MAPS/mca_arr` group
  - Integrated spectra array in `MAPS/int_spec` group

  An example dataset is provided in the `assets` folder. We recommend using [H5Web](https://h5web.panosc.eu/) to view HDF5 files.

  For numpy array data, use the `create_dataset` function in `mapstorch.io`:

  ```python
  def create_dataset(
      spec_vol,
      energy_dim,
      output_path,
      fit_elems=None,
      dtype=np.float32,
      compression="gzip",
      compression_opts=4,
  ):
      """Create an HDF5 file compatible with read_dataset function.

      Args:
          spec_vol: 3D numpy array or path to .npy file containing spectral volume
          energy_dim: Which dimension (0,1,2) contains the energy channels
          output_path: Path where to save the HDF5 file
          fit_elems: Optional list of element names
          dtype: numpy dtype for data storage (e.g. np.float32, np.float16). Default: np.float32
          compression: Compression filter to use. Options: 'gzip', 'lzf', None. Default: 'gzip'
          compression_opts: Compression settings. For 'gzip', this is the compression level (0-9). Default: 4
      """
  ```



  We provide marimo notebooks in the `apps` folder that can be run as web apps (download the notebooks and run them in a Python environment with `mapstorch` installed):



  ```
  marimo run guess_elements.py
  ```

  [![Guessing elements](https://img.youtube.com/vi/dJQiLpy4r-Q/0.jpg)](https://www.youtube.com/watch?v=dJQiLpy4r-Q)



  ```
  marimo run optimize_parameters.py
  ```

  [![Optimizing parameters](https://img.youtube.com/vi/d8Z2n-97f9Q/0.jpg)](https://www.youtube.com/watch?v=d8Z2n-97f9Q)



  The `scripts` folder contains example scripts like `fit_spec.py` for fitting integrated spectra. Usage:

  ```
  python fit_spec.py DATASET.h5 -e 12.0
  ```

  For all options:

  ```
  python scripts/fit_spec.py -h
  ```



  - Bug reports and feature requests: Open GitHub Issues
  - Contributions: Fork repository, create branch, submit pull request
  - XRF analysis help: Contact xyin@anl.gov or aglowacki@anl.gov



  This research used resources of the Advanced Photon Source, an U.S. Department of Energy (DOE) Office of Science User Facility operated for the DOE Office of Science by Argonne National Laboratory under Contract No. DE-AC02-06CH11357. The authors acknowledge funding support from Argonne LDRD 2023-0049.


pkgId: 5f571c10293dc6f30efb075c82913824443e3a2e1648f1114a5a8dc56da0d7bd
name: python-maptasker-help
arch: noarch
version: 6.0.6
epoch: 0
release: 1
summary: Development documents and examples for maptasker
url: https://github.com/mctinker/Map-Tasker
rpm_license: MIT License (MIT)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maptasker-6.0.6-1.src.rpm
location_href: Packages/python-maptasker-help-6.0.6-1.noarch.rpm
checksum_type: sha256
description:
  This is an application in support of [Tasker](https://tasker.joaoapps.com/) that is intended to run on a MAC/PC/Linux/Win11 desktop.

  An older version, which requires Python version 3.10 rather than 3.11 or higher, is available as version 2.6.3...
      `pip install maptasker==2.6.3`

  For further details, refer to [the project on Github.](https://github.com/mctinker/Map-Tasker)


pkgId: 069a5b5fc280bcab6e710b750af21c3cc946b093363ede444dc6edc8491a73ab
name: python-marge-bot-help
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Development documents and examples for marge-bot
url: https://gitlab.com/marge-org/marge-bot
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-marge-bot-0.14.0-1.src.rpm
location_href: Packages/python-marge-bot-help-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
  [![pipeline status](https://gitlab.com/marge-org/marge-bot/badges/main/pipeline.svg)](https://gitlab.com/marge-org/marge-bot/-/commits/main)
  [![Latest Release](https://gitlab.com/marge-org/marge-bot/-/badges/release.svg)](https://gitlab.com/marge-org/marge-bot/-/releases)

  **marge-bot** is a merge bot for advanced merge request workflows on GitLab.
  Marge helps keep your main branch green, and comes with a set of features to make
  managing merge requests at scale easier. It improves on GitHub's
  [merge queue](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)
  and GitLab's [merge train](https://docs.gitlab.com/ee/ci/pipelines/merge_trains.html)
  workflows by automatically handling rebases and merges, batching merge requests, and more.

  Marge-bot offers a simple workflow: when a merge request is ready, just
  assign it to the marge-bot user, and let her do all the rebase-wait-retry for you. If
  anything goes wrong (merge conflicts, tests that fail, etc.) she'll leave a
  message on the merge request, so you'll get notified. Marge-bot can handle an
  adversarial environment where some developers prefer to merge their own changes,
  so the barrier for adoption is really low.

  Whether marge-bot will or will not wait for pipeline to succeed depends on the value of
  "Pipelines must succeed" setting in your project. It is available in all Gitlab
  versions, and should not be a barrier.

  Since she is at it, she can optionally provide some other goodies like tagging
  of commits (e.g. `Reviewed-by: ...`) or preventing merges during certain hours.


pkgId: 8fdf08f7fe6516ddba58fa404b6f59186f0476a8dfd24d3163dfee41eab22ccc
name: python-maria-help
arch: noarch
version: 1.1.4
epoch: 0
release: 1
summary: Development documents and examples for maria
url: https://github.com/thomaswmorris/maria
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maria-1.1.4-1.src.rpm
location_href: Packages/python-maria-help-1.1.4-1.noarch.rpm
checksum_type: sha256
description:
  *maria blows the stars around / and sends the clouds a-flyin’*
  ``maria`` is a complete simulator of ground-based millimeter- and submillimeter-wave telescopes. Tutorials for installation and usage can be found in the `documentation <https://www.thomaswmorris.com/maria>`_.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2024 Thomas W. Morris All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: d3c1e02f55c43a2904760396ae16dd4d9c16eabc9cbf1691188ed4c733b1b60c
name: python-marimba-help
arch: noarch
version: 0.4.8
epoch: 0
release: 1
summary: Development documents and examples for marimba
url: https://pypi.org/project/marimba/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-marimba-0.4.8-1.src.rpm
location_href: Packages/python-marimba-help-0.4.8-1.noarch.rpm
checksum_type: sha256
description:
  - [Overview](#overview)
  - [Design](#design)
  - [Features](#features)
  - [Installation](#installation)
  - [Getting Started](#getting-started)
  - [Documentation](#documentation)
  - [Contributing](#contributing)
  - [License](#license)
  - [Contact](#contact)


pkgId: 8b105ccdd4115d28e9685eb45b212a8aa9f5fd6dd9bee14660c830b8fe5add4d
name: python-marionette-predeployed-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for marionette-predeployed
url: https://github.com/skalenetwork/marionette
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-marionette-predeployed-1.0.0-1.src.rpm
location_href: Packages/python-marionette-predeployed-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A tool for generating predeployed marionette smart contract



  ```console
  pip install marionette-predeployed
  ```



  ```python
  from marionette_predeployed import  UpgradeableMarionetteGenerator, MARIONETTE_ADDRESS, MARIONETTE_IMPLEMENTATION_ADDRESS

  PROXY_ADMIN_ADDRESS = '0xd200000000000000000000000000000000000000'
  MAINNET_OWNER_ADDRESS = '0xd200000000000000000000000000000000000001'
  SCHAIN_OWNER_ADDRESS = '0xD200000000000000000000000000000000000002'
  MESSAGE_PROXY_FOR_SCHAIN_ADDRESS = '0xd200000000000000000000000000000000000003'

  marionette_generator = UpgradeableMarionetteGenerator()

  genesis = {
      
      'alloc': {
          **marionette_generator.generate_allocation(
              contract_address=MARIONETTE_ADDRESS,
              implementation_address=MARIONETTE_IMPLEMENTATION_ADDRESS,
              proxy_admin_address=PROXY_ADMIN_ADDRESS,
              schain_owner=MAINNET_OWNER_ADDRESS,
              marionette=MARIONETTE_ADDRESS,
              owner=SCHAIN_OWNER_ADDRESS,
              ima=MESSAGE_PROXY_FOR_SCHAIN_ADDRESS,
          )
      }
  }

  ```


pkgId: 65a078c3a9da8a5d8521c7a61245ac5546775fcd8b4a305f4bd649021318a017
name: python-markdown-customblocks-help
arch: noarch
version: 1.5.3
epoch: 0
release: 1
summary: Development documents and examples for markdown-customblocks
url: https://vokimon.github.io/markdown-customblocks
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-markdown-customblocks-1.5.3-1.src.rpm
location_href: Packages/python-markdown-customblocks-help-1.5.3-1.noarch.rpm
checksum_type: sha256
description:
  ![Logo](http://vokimon.github.io/markdown-customblocks/img/logo-customblocks.svg)



  [![CI](https://github.com/vokimon/markdown-customblocks/actions/workflows/main.yml/badge.svg)](https://github.com/vokimon/markdown-customblocks/actions/workflows/main.yml)
  [![Coverage](https://img.shields.io/coveralls/vokimon/markdown-customblocks/master.svg?style=flat-square&label=Coverage)](https://coveralls.io/r/vokimon/markdown-customblocks)
  [![PyPi](https://img.shields.io/pypi/v/markdown-customblocks.svg?style=flat-square&label=PyPI)](https://pypi.org/project/markdown-customblocks/)
  [![license: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
  [![downloads](https://img.shields.io/pypi/dm/markdown-customblocks.svg?style=flat-square&label=PyPI%20Downloads)](https://pypi.org/project/markdown-customblocks/)
  <!--
  [![image](https://img.shields.io/pypi/pyversions/markdown-customblocks.svg?style=flat-square&label=Python%20Versions)](https://pypi.org/project/markdown-customblocks/)
  [![image](https://img.shields.io/pypi/implementation/markdown-customblocks.svg?style=flat-square&label=Python%20Implementations)](https://pypi.org/project/markdown-customblocks/)
  -->

  Customblocks is an extension for [Python-Markdown]
  that settles a **common markup** for **parametrizable and nestable components**
  whose output can be **redefined** by means of a simple Python function.

  Many off-the-shelf components are provided such as
  div-containers, admonitions, figures, link cards, maps...
  and some embeded widgets from common sites (wikipedia, youtube, vimeo, peertube, mastodon, twitter, facebook, instagram, goteo, verkami...)

  It also includes convenience tools to ease component definition:
  hyperscript html generation, cached page fetching and metadata page extraction.

  [Python-Markdown]: https://python-markdown.github.io/




  To install:

  ```bash
  $ pip install markdown-customblocks
  ```

  And then activate it as any other Markdown extension.

  From command line:

  ```bash
  $ markdown -x customblocks ...
  ```

  In Python code:

  ```python
  import markdown
  md = markdown.Markdown(extensions=["customblocks"])
  md.convert(markdowncontent)
  ```

  In [Pelican](https://blog.getpelican.com/) config:

  ```python
  MARKDOWN = {
      'extensions': [
          'customblocks',
      ],
  }
  ```

  For [MkDocs](https://www.mkdocs.org), add this to `mkdocs.yml`:

  ```yaml
  markdown_extensions:
    - customblocks
  ```

  If you need to specify additional parameters for the extension,
  refer to the documentation of your generator.




  Customblocks extension parses markup structures like this one:

  ```markdown
  ::: mytype "value 1" param2=value2
      Indented **content**
  ```

  And, by default, generates HTML like this:

  ```html
  <div class="mytype value-1" param2="value2">
     <p>Indented <b>content</b></p>
  </div>
  ```

  This is the output of the default generator: `container`.
  But we could bound `mytype` to a custom Python function like the following one:

  ```python
  def mygenerator(ctx, param1, param2):
      return f"""<div attrib1="{param1}" attrib2="{param2}">{ctx.content}</div>"""
  ```

  And then, previous Markdown would generate this other HTML:

  ```html
  <div attrib1="value 1" attrib2="value2">Indented **content**</div>
  ```

  Notice that this function is not escaping any received value
  and is not converting anything in the content to Markdown.
  Luckily, `customblocks` provides some useful tools for that:
  the hyperscript generator and the Markdown subparser:

  ```python
  from customblocks.utils import E, Markdown

  def mygenerator(ctx, param1, param2):
      return E('', attrib1=param1, attrib2=param2,
          Markdown(ctx.content, ctx.parser)
      )
  ```

  You can read more about them at the [related documentation](https://vokimon.github.io/markdown-customblocks/defining-generators/#hyperscript).



  For convenience, `customblocks` also provides the following predefined generators:

  - [`container`](https://vokimon.github.io/markdown-customblocks/generators-container/):
      A div element with arbitrary classes, attributes and content. This is the default when no type matches.
  - [`admonition`](https://vokimon.github.io/markdown-customblocks/generators-admonition/):
      Admonitions, boxes for notes, warnings... (quite similar to the [standard extra extension][ExtraAdmonitions]).
      It is bound to types `note`,  `info`, `error`, `warning`....
  - [`figure`](https://vokimon.github.io/markdown-customblocks/generators-figure/):
      Full featured figures with captions, lightbox...
  - [`map`](https://vokimon.github.io/markdown-customblocks/generators-map/):
      Maps from [OpenStreetMaps.org](https://openstreetmap.org)
  - [`linkcard`](https://vokimon.github.io/markdown-customblocks/generators-linkcard/):
      External link cards (like Facebook and Twitter do, when you post a link)
  - [`wikipedia`](https://vokimon.github.io/markdown-customblocks/generators-wikipedia/):
      Wikipedia article card by lemma (and language)
  - [`youtube`](https://vokimon.github.io/markdown-customblocks/generators-youtube/):
      Embeded videos from youtube.
  - [`vimeo`](https://vokimon.github.io/markdown-customblocks/generators-vimeo/):
      Embeded videos from vimeo.
  - [`peertube`](https://vokimon.github.io/markdown-customblocks/generators-peertube/):
      Embeded videos from [peertube](https://joinpeertube.org)
  - [`mastodon`](https://vokimon.github.io/markdown-customblocks/generators-mastodon/):
      Embeded [mastodon](https://joinmastodon.org) posts
  - [`twitter`](https://vokimon.github.io/markdown-customblocks/generators-twitter/):
      Embeded tweets
  - [`facebook`](https://vokimon.github.io/markdown-customblocks/generators-facebook/):
      Embeded post from facebook
  - [`instagram`](https://vokimon.github.io/markdown-customblocks/generators-instagram/):
      Embeded post from instagram
  - [`verkami`](https://vokimon.github.io/markdown-customblocks/generators-verkami/):
      Fund raising project widget in [Verkami]
  - [`goteo`](https://vokimon.github.io/markdown-customblocks/generators-goteo/):
      Fund raising project widget in [Goteo]

  [ExtraAdmonitions]: https://python-markdown.github.io/extensions/admonition/




  This is a more complete example of markup:

  ```markdown
  ::: mytype param1 key1=value1 "other param" key2='value2 with words' flag1 noflag2
      Indented **content**

      The block ends whenever the indentation stops
  This unindented line is not considered part of the block
  ```

  **The headline:**
  The line starting with `:::` is the _headline_.
  It specifies, first, the block type (`mytype`) followed by a set of _values_
  that will be passed to the generator as parameters.


  **Block type:**
  The type is used to select the generator function.
  If there is no generator bound to the type, the div-container generator, will be used by default.

  **Quotes:**
  Muti-word values can be passed by using either single or double quotes.
  You can skip quotes if your value is single worded.

  **Explicit keywords:**
  Also some values may target an explicit parameter with a _key_.
  This works as follows:
  from the available block parameters, values with a key are set first,
  then the remaining unset parameters are filled by position.

  **Flags (bools):**
  Boolean parameters (flags) can be set by just adding a value with the name of the flag, like `flag1` in the example.
  And they can be unset by adding the name with a `no` prefix, like `noflag2` in the example.

  **Content:**
  After the _headline_, several lines of indented _content_ may follow.
  The content ends with the very first non-emtpy line back on the previous indentation.

  Indentation is removed from the content for the generator to process it.
  A block type may choose to interpret this content as markdown as well.
  So you can have nested blocks by adding extra indentation.
  For example:

  ```markdown
  ::: recipe
      
      ::: ingredients "4 persons"
          - two spons of suggar
          - a glass of tap water
      ::: mealphoto sweetwater.jpg
          Looks gorgeus!
      Drop the suggar into the glass. Stir.
  ```

  ::: note
      A closing `:::` tag is optional.
      For most cases, indentation should be enough, visually, and functionally.
      But, seldomly, it is necessary.
      Like in the example below, where
      the mealphoto content would be mixed with
      the later code block

          ::: mealphoto sweetwater.jpg
                  Looks gorgeus!
          :::
                  This is a code block by indentation




  - [Full documentation](https://vokimon.github.io/markdown-customblocks)
  - [Code](https://github.com/vokimon/markdown-customblocks)
  - [Release History](https://vokimon.github.io/markdown-customblocks/CHANGES)
  - [Road map](https://vokimon.github.io/markdown-customblocks/TODO)
  - [Motivation and design choices](https://vokimon.github.io/markdown-customblocks/motivation)
  - [Inspiration and kudos](https://vokimon.github.io/markdown-customblocks/inspiration)

rpm_license:
[cell repeats an earlier one in this file: 33880 characters]


pkgId: cad5c7fc70d6f4c5195c3c1346e7a7b0f96fbad7bbb389031767d8e6114e8156
name: python-markdown-table-repair-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for markdown-table-repair
url: https://github.com/MAbdanM/markdown-table-repair
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-markdown-table-repair-0.1.0-1.src.rpm
location_href: Packages/python-markdown-table-repair-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ```markdown-table-repair``` is a python package designed to repair and clean malformed markdown tables and convert them into structured pandas.


  - Inconsistent column and header count
  ```
  Header1 | Header2 |
  |---|---|
  Value1  | Value2 | Value3
  ```
  - Improperly formatted header
  ```
  | Header1 | Header2 | Header3
  |---|---|---
  Value1 | Value2 | Value3 |
  ```
  - Missing separator
  ```
  | Header1 | Header2 | Header3
  Value1 | Value3
  ```
  - Unclosed table blocks
  ```
  | Header1 | Header2 | Header3
  |---|---|---
  Value1 | Value2 | Value3
  ```
  - No separator in header row
  ```
   Header1 | Header2 |
   |---|---|
    Value1  | Value2 | Value3
  ```
  - Unnecessary whitespaces
  - etc.


  To use the markdown-table-repair package, follow these steps:
  1. **Install the Package**
  Before using markdown-table-repair, ensure that ```pandas``` is installed.
  ```
  pip install markdown-table-repair
  ```
  2. **Repair Malformed Tables**
  ```
  import markdown_table_repair as mtr

  malformed_table = """| Header1 | Header2 |  Header3 \n|---|---|\n Value1  | Value2 | Value3"""
  repaired_table = mtr.repair(malformed_table)
  print(repaired_table)
  ```
  3. **Optional - Convert to DataFrame**
  ```


  dataframe = repaired_table.to_df()
  ```

  Your contributions to this project are welcome! Feel free to fork the repository, create pull requests, and help improve the markdown-table-repair package.


  This project is licensed under the MIT License. See the LICENSE file for details.


pkgId: bab0a97c219e46e1f6f26da7ccb5021c3d230a31649ccf98acb193f2ec6903d8
name: python-markitdown-help
arch: noarch
version: 0.0.1a3
epoch: 0
release: 1
summary: Development documents and examples for markitdown
url: https://pypi.org/project/markitdown/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-markitdown-0.0.1a3-1.src.rpm
location_href: Packages/python-markitdown-help-0.0.1a3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/markitdown.svg)](https://pypi.org/project/markitdown/)

  The MarkItDown library is a utility tool for converting various files to Markdown (e.g., for indexing, text analysis, etc.)

  It presently supports:

  - PDF (.pdf)
  - PowerPoint (.pptx)
  - Word (.docx)
  - Excel (.xlsx)
  - Images (EXIF metadata, and OCR)
  - Audio (EXIF metadata, and speech transcription)
  - HTML (special handling of Wikipedia, etc.)
  - Various other text-based formats (csv, json, xml, etc.)
  - ZIP (Iterates over contents and converts each file)



  You can install `markitdown` using pip:

  ```python
  pip install markitdown
  ```

  or from the source

  ```sh
  pip install -e .
  ```


  The API is simple:

  ```python
  from markitdown import MarkItDown

  markitdown = MarkItDown()
  result = markitdown.convert("test.xlsx")
  print(result.text_content)
  ```

  To use this as a command-line utility, install it and then run it like this:

  ```bash
  markitdown path-to-file.pdf
  ```

  This will output Markdown to standard output. You can save it like this:

  ```bash
  markitdown path-to-file.pdf > document.md
  ```

  You can pipe content to standard input by omitting the argument:

  ```bash
  cat path-to-file.pdf | markitdown
  ```

  You can also configure markitdown to use Large Language Models to describe images. To do so you must provide `llm_client` and `llm_model` parameters to MarkItDown object, according to your specific client.


  ```python
  from markitdown import MarkItDown
  from openai import OpenAI

  client = OpenAI()
  md = MarkItDown(llm_client=client, llm_model="gpt-4o")
  result = md.convert("example.jpg")
  print(result.text_content)
  ```

  You can also use the project as Docker Image:

  ```sh
  docker build -t markitdown:latest .
  docker run --rm -i markitdown:latest < ~/your-file.pdf > output.md
  ```



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

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

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



  To run tests, install `hatch` using `pip` or other methods as described [here](https://hatch.pypa.io/dev/install).

  ```sh
  pip install hatch
  hatch shell
  hatch test
  ```



  Please run the pre-commit checks before submitting a PR.

  ```sh
  pre-commit run --all-files
  ```



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


pkgId: cd6be6f69724809d138882e6e650bd039be54890dbb2637030b96cb652f5303c
name: python-marlin-data-help
arch: noarch
version: 8.0.1
epoch: 0
release: 1
summary: Development documents and examples for marlin-data
url: https://pypi.org/project/marlin-data/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-marlin-data-8.0.1-1.src.rpm
location_href: Packages/python-marlin-data-help-8.0.1-1.noarch.rpm
checksum_type: sha256
description:
  &copy; Rahul Tandon, RS Aqua 2024


  ``marlin_data`` allows access to RSA's acoustic signature database. The module requests the RSA acoustic dataset required in order to run a machine learning (ML). Current version of ``marlin_data`` provides a predefined dataset for proof of concept and tutorial purposes. Future versions will allow for more specific datasets as well as definig training and validation datasets separately.
  > **NOTE**  | Numerical data in ``marlin_data`` is defined using Python's numpy and pandas library.


  <!--
  > One-Line Box made with Blockquote -->


  `
  import numpy as np
  import pandas as pd
  import requests, json
  import logging
  import dotenv
  import os, sys
  from dataclasses import dataclass
  import random
  `



  `from marlin_data import *`








  Each iteration over the Marlin data feed will provide once instance of the datafeed and simulation data / snapshots. Frequency time series in numpy and a pandas dataframe is available along with descrictive metadata. Feed data is an iterable class which can be looped over allowing for an incremental datafeed.

  `Feed Instance` -> `frequency_ts_np`

  The frequency time series for this data snapshot ( NumPy Array )

          for feed_instance in data_feed: frequency_np_array = feed_instance['frequency_ts_np']

  `Feed Instance` -> `frequency_ts_pd`

  The frequency time series for this data snapshot (pandas `DataFrame`)

          for feed_instance in data_feed: frequency_data_frame = feed_instance['frequency_ts_pd']

  `Feed Instance` -> `meta_data`

  Metadata for the associated snapshot. Metadata is a dictionary with the following defined fields:

  * `snapshot_id` : unique id for the snapshot
  * `data_frame_start` : timestamp for the start of the snapshot data frame
  * `data_frame_end` : timestamp for the end of the snapshot data frame
  * `listener_location` : geo location of the listening device for snapshot
  * `location_name` : human friendly name of listening location
  * `frame_delta_t` : delta t for the snapshot (s)
  * `sample_rate` : frequency recorder sample rate



  `SignatureData` dataclass is accessible from `MarlinData` -> `signature_data`. Key values are stored in `MarlinData` -> `signature_index`.

          @dataclass
          class SignatureData:
                  frequency_ts_np : np.array
                  frequency_ts_pd : pd.DataFrame
                  meta_data : {}

  Metadata for the associated snapshot. Metadata is a dictionary with the following defined fields:

  * `snapshot_id` : unique id for the snapshot
  * `data_frame_start` : timestamp for the start of the snapshot data frame
  * `data_frame_end` : timestamp for the end of the snapshot data frame
  * `listener_location` : geo location of the listening device for snapshot
  * `location_name` : human friendly name of listening location
  * `frame_delta_t` : delta t for the snapshot (s)
  * `sample_rate` : frequency recorder sample rate




  `SimulationData` dataclass is accessible from `MarlinData` -> `simulation_data`. Key values are stored in `MarlinData` -> `simulation_index`.

          @dataclass
          class SimulationData:
              frequency_ts_np : np.array
              frequency_ts_pd : pd.DataFrame
              meta_data : {}
              snapshot : bool = True

  Metadata for the associated snapshot. Metadata is a dictionary with the following defined fields:

  * `snapshot_id` : unique id for the snapshot
  * `data_frame_start` : timestamp for the start of the snapshot data frame
  * `data_frame_end` : timestamp for the end of the snapshot data frame
  * `listener_location` : geo location of the listening device for snapshot
  * `location_name` : human friendly name of listening location
  * `frame_delta_t` : delta t for the snapshot (s)
  * `sample_rate` : frequency recorder sample rate



  Instantiate a `MarlinData` class.

          ` marlin_data = MarlinData(load_args={})`

  Download signature data from RSA signature database.

          `marlin_data.download_signatures(load_args={})`

  Download simulation / ML run data required for datafeed.

          `marlin_data.download_simulation_snapshots(load_args={})`

  load_args:

  * `limit`       : maximum number of downloads (Require in init())
  * `signature_ids` : vector of signature ids
  * `ss_ids` : vector of snapshot ids◊
  * `location` : vector of locations







  Create the Marlin datafeed. This data feed can be iterated over in order to simulate a data feed into a model.

          `data_feed = MalrinDataStreamer()`

  Connect the downloaded data to the datafeed instance.

          `data_feed.init_data(marlin_data.simulation_data, marlin_data.simulation_index) `

  Iterate over the datafeed.

          for data_inst in data_feed:
                  print (data_inst)
  `


pkgId: 093509589ca0c7fa5790ca0c8cda33361293860ccd671b12c5c2db5278123fe7
name: python-mars-similarity-tools-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for mars-similarity-tools
url: https://pypi.org/project/mars-similarity-tools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mars-similarity-tools-0.3.2-1.src.rpm
location_href: Packages/python-mars-similarity-tools-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  A small tools library for getting vector similarity measurement working in no time.


  Here's a basic similarity search and vectorization example. We instantiate a `VectorSimilarityService` which needs an `Augmentor` of some kind. The `Augmentor` should be responsible for taking objects inherited by `SimilarityObject` class and return vectorized grouped objects (as a `VectorGroup` object). Before a `SimilarityObject` can be transformed into a `VectorGroup` it will pass the `GroupParser` first. That one will rearrange the properties of the objects into groups, which is given in the parser. We need to do this since multiple properties of an object should in the end be represented by one vector together.

  ```python


  @dataclass(frozen=True) # "frozen" is Important!
  class Bicycle(SimilarityObject):

      id: str
      color_name: str
      color_description: str
      wheel_size: int
      model: str


  service = VectorSimilarityService(
      augmentor=ItemVectorizer(
          vectorizer=Vectorizer(),
          parser=GroupParser(
              name=Bicycle.__class__.__name__,
              children=[
                  GroupParser(
                      name="color",
                      children=[
                          PropertyParser(
                              name="color name",
                              dtype=str,
                              path=["color_name"]
                          ),
                          PropertyParser(
                              name="color description",
                              dtype=str,
                              path=["color_description"]
                          ),
                      ],
                  ),
                  PropertyParser(
                      name="wheel_size",
                      dtype=int,
                      path=["wheel_size"]
                  ),
                  PropertyParser(
                      name="model",
                      dtype=str,
                      path=["model"]
                  ),
              ]
          ),
      )
  )


  objects = [
      Bicycle(
          id="1",
          color_name="red",
          color_description="A red bicycle",
          wheel_size=26,
          model="mountain"
      ),
      Bicycle(
          id="2",
          color_name="blue",
          color_description="A blue bicycle",
          wheel_size=26,
          model="mountain"
      ),
      Bicycle(
          id="3",
          color_name="green",
          color_description="A green bicycle",
          wheel_size=28,
          model="racer"
      ),
  ]


  similarity_result = service.similarity_search(
      objects,
      Bicycle(
          id="4",
          color_name="yellow",
          color_description="A yellow bicycle",
          wheel_size=28,
          model="racer"
      ),
  )


  sorted_similarity_result = sorted(
      similarity_result,
      key=lambda x: x.score
  )

  assert len(sorted_similarity_result) == 3
  assert type(sorted_similarity_result[0].obj) == Bicycle
  assert type(sorted_similarity_result[1].obj) == Bicycle




  biased_similarity_result = service.similarity_search(
      objects,
      Bicycle(
          id="4",
          color_name="yellow",
          color_description="A yellow bicycle",
          wheel_size=28,
          model="racer"
      ),
      bias={"color": 1.2, "wheel_size": 0.2, "model": 0.2}
  )


  sorted_biased_similarity_result = sorted(
      biased_similarity_result,
      key=lambda x: x.score
  )

  assert len(sorted_biased_similarity_result) == 3
  assert type(sorted_biased_similarity_result[0].obj) == Bicycle
  assert type(sorted_biased_similarity_result[1].obj) == Bicycle
  ```


pkgId: 82cb2bec559f02f8b547e243482d74ee1b6667fa77d61b0d3568f5fd59a0e8a2
name: python-martian-adapters-help
arch: noarch
version: 7.2.0
epoch: 0
release: 1
summary: Development documents and examples for martian-adapters
url: https://pypi.org/project/martian-adapters/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-martian-adapters-7.2.0-1.src.rpm
location_href: Packages/python-martian-adapters-help-7.2.0-1.noarch.rpm
checksum_type: sha256
description:
  List of currently [supported models](https://withmartian.github.io/llm-adapters/)



  The Adapters package facilitates communication between different language model APIs by providing a unified interface for interaction. This ensures ease of use and flexibility in integrating multiple models from various providers.

  The package can be installed an used via pip:

  ```
  pip install martian-adapters
  ```





  - Python version: 3.11.10
  - [Poetry](https://python-poetry.org/docs/#installation)



  ```bash
  poetry install
  poetry run pre-commit install
  ```



  To run pre-commit manually:

  ```bash
  poetry run pre-commit run --all-files
  ```



  For versioning we follow [Semantic Versioning](https://semver.org)



  The package requires certain environment variables to be set by the users:

  - Copy `.env-example` to `.env` and populate it with appropriate values.



  ```bash
  poetry run pytest
  ```



  ```python
  from adapters import AdapterFactory
  from adapters.types import Conversation, ConversationRole, Turn

  adapter = AdapterFactory.get_adapter_by_path("openai/openai/gpt-4o-mini")

  conversation = Conversation(
      [Turn(role=ConversationRole.user, content="Hi")]
  )

  adapter.execute_sync(conversation)
  ```

  Adapter paths follows the format `provider/vendor/model_name`. Use `AdapterFactory.get_supported_models()` to retrieve all supported models. For a given model, `model.get_path()` returns the adapter path.





  1. **Existing Providers:**
     Add new models to the `MODELS` array if the provider is already supported.

  2. **New Providers:**
     - If the provider follows the OpenAI format, model integration is straightforward. See the "_Fireworks_" provider class as an example.
     - For providers with different schemas, see the "_Anthropic_" provider class for guidance.



  1. **Add the Provider and Model:** Update `provider_adapters/__init__.py` and test files accordingly.
  2. **Write Tests:** Add tests in the relevant directories. Use `@pytest.mark.vcr` for tests making network requests.
  3. **Run Tests:**

     ```bash
     poetry run pytest
     ```

  4. **Check-in Cassette Files:** Include any new cassette YAML files in your commit.
  5. **Send a Pull Request:** Ensure all tests pass before requesting a review.



  Use the `poetry run pytest --record-mode=rewrite` option with pytest to update cassette files.



  Some models may only be accessible from specific locations (e.g., the U.S.). In such cases, running tests might require access to a U.S.-based server.

  This documentation provides a streamlined approach to using and contributing to the Adapters package, emphasizing practical steps and clear examples.





  To optimize throughput and performance, we provide options to configure HTTP networking parameters:

  ```env
  ADAPTERS_MAX_KEEPALIVE_CONNECTIONS_PER_PROCESS = 100
  ADAPTERS_MAX_CONNECTIONS_PER_PROCESS = 1000
  ADAPTERS_HTTP_CONNECT_TIMEOUT = 5
  ADAPTERS_HTTP_TIMEOUT = 600
  ```



  For stress testing or other purposes, you can override all base URLs by setting the following in your .env file:

  ```env
  _ADAPTERS_OVERRIDE_ALL_BASE_URLS_ = "https://new-base-url.com/api"
  ```

  This setting ensures that all LLM API calls will route to the specified new base URL.


pkgId: 00cee1548143149d6669fa5a229b5704dd7cd6565013e44adf621fdded3cfbd7
name: python-martypy-help
arch: noarch
version: 3.7.1
epoch: 0
release: 1
summary: Development documents and examples for martypy
url: http://github.com/robotical/martypy
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-martypy-3.7.1-1.src.rpm
location_href: Packages/python-martypy-help-3.7.1-1.noarch.rpm
checksum_type: sha256
description:
  Python library to communicate with Marty the Robot V1 and V2 by Robotical

  [See the API Documentation](https://userguides.robotical.io/martyv2/documentation/python_function_reference)

  To regenerate documentation:
  - pip install -r dev-requirements.txt
  - pydoc-markdown --server --open
  - markdown_mmd api-documentation-edited.md -t dokuwiki -o docs-wiki.wiki
  OR, automatically:
  - run docgen.bat (or docgen.sh on Mac/Linux) from Python environment (will also create a docs-wiki.wiki file with the dokuwiki format)





  If you cloned the repository or downloaded the source code to try the [example scripts](examples),
  you will need to make sure you have MartyPy installed before you can run the examples.

  The easiest way to install MartyPy is with the `pip install martypy` script as explained in
  [step 2 here](https://userguides.robotical.io/martyv2/userguides/python/setting_up_python_on_your_computer).

  Once martypy is installed you can run each example using python.
  The following (for the dance example) assumes you have connected your marty using the USB cable to a Windows computer

  python example_dance.py USB

  To run the sound example over WiFi when your Marty is connected on IP address 192.168.86.10, use:

  python example_sound.py WiFi 192.168.0.10

  If you would like to make modifications to the martypy library itself, it will be better to install
  it from source using the command `pip install --editable /path/to/martypy/repo` (replacing
  `/path/to/martypy/repo` as appropriate of course).

  If you do not want to "`pip install`" the MartyPy library, you can add the following 4 lines at the
  top (before any other code) of each script you want to run:

  ```python
  import sys
  import pathlib
  cur_path = pathlib.Path(__file__).parent.resolve()
  sys.path.append(str(cur_path.parent.resolve()))
  ```


pkgId: 2548481f4e12cda49faf35597d24a938f777f4046904f09a9a7f41e76d670729
name: python-mas-devops-help
arch: noarch
version: 1.13.2
epoch: 0
release: 1
summary: Development documents and examples for mas-devops
url: https://github.com/ibm-mas/python-devops
rpm_license: Eclipse Public License - v1.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mas-devops-1.13.2-1.src.rpm
location_href: Packages/python-mas-devops-help-1.13.2-1.noarch.rpm
checksum_type: sha256
description:
  |Code style: PEP8| |Flake8: checked| |GitHub Actions Workflow Status|
  |PyPI - Version| |PyPI - Python Version| |PyPI - Downloads|


pkgId: 78f05c58c4f21c2a6bc6a75c06aa425cdd16e7d044ed6bcc39a17dc4f0ecd143
name: python-mas-framework-help
arch: noarch
version: 0.1.12
epoch: 0
release: 1
summary: Development documents and examples for mas-framework
url: https://pypi.org/project/mas-framework/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mas-framework-0.1.12-1.src.rpm
location_href: Packages/python-mas-framework-help-0.1.12-1.noarch.rpm
checksum_type: sha256
description:
  ⚠️ **EXPERIMENTAL STATUS**: This project is in early development and APIs are subject to breaking changes. Not recommended for production use.

  MAS AI is a Python framework for building multi-agent systems, focusing on reliable message passing and state management between agents.



  -   **Simple Agent Creation** - Declarative agent definition with capabilities
  -   **Type-Safe State Management** - Immutable state management with Pydantic models
  -   **Message Routing** - Reliable agent-to-agent communication
  -   **Agent Discovery** - Find agents by capabilities
  -   **Lifecycle Management** - Controlled agent startup/shutdown



  1. Prerequisites:

  ```bash

  redis-server


  pip install mas-framework
  ```

  2. Create an Agent:

  ```python
  from mas.sdk.agent import Agent
  from mas.sdk.decorators import agent
  from mas.protocol import Message
  from mas.sdk.state import AgentState
  from pydantic import Field


  class MyState(AgentState):
      counter: int = Field(default=0)
      name: str = Field(default="")

  @agent(
      agent_id="example_agent",
      capabilities=["math", "storage"],
      metadata={"version": "0.1.0"},
      state_model=MyState  # Optional custom state model
  )
  class ExampleAgent(Agent):
      async def on_message(self, message: Message) -> None:
          
          print(f"Got message: {message.payload}")

          
          await self.update_state({
              "counter": 42,
              "name": "example"
          })

          
          current_state = self.state
          print(f"Counter: {current_state.data['counter']}")
  ```

  3. Run the Agent:

  ```python
  import asyncio
  from mas import mas_service

  async def main():
      async with mas_service() as context:
          agent = await ExampleAgent.build(context)
          try:
              while True:
                  await asyncio.sleep(1)
          finally:
              await agent.stop()

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





  Agents maintain immutable state with type-safe updates:

  ```python

  class MyState(AgentState):
      counter: int = Field(default=0)
      status: str = Field(default="idle")


  await agent.update_state({
      "counter": 42,
      "status": "ready"
  })


  current_state = agent.state
  print(f"Counter: {current_state.data['counter']}")


  await agent.reset_state()


  async def on_state_change(new_state: MyState) -> None:
      print(f"State changed: {new_state.model_dump()}")

  agent.subscribe_to_state(on_state_change)
  ```



  Pattern matching for message types:

  ```python
  async def on_message(self, message: Message) -> None:
      match message.message_type:
          case MessageType.AGENT_MESSAGE:
              await self.handle_agent_message(message)
          case MessageType.DISCOVERY_RESPONSE:
              await self.handle_discovery(message)
  ```



  Find other agents by capabilities:

  ```python

  await agent.runtime.discover_agents(capabilities=["math"])
  ```



  ```python
  class MyAgent(Agent):
      async def on_start(self) -> None:
          """Called when agent starts"""
          await self.update_state({"status": "starting"})

      async def on_stop(self) -> None:
          """Called when agent stops"""
          await self.cleanup_resources()
  ```



  As this is experimental software, there are several limitations:

  -   No authentication/authorization system yet
  -   Limited error recovery mechanisms
  -   Message delivery is not guaranteed
  -   No persistent storage (in-memory only)
  -   APIs may change without notice
  -   Limited testing in distributed environments
  -   No proper documentation yet



  This project is under active development. Current focus areas:

  -   Stabilizing core APIs
  -   Improving error handling
  -   Adding authentication
  -   Adding persistent storage
  -   Documentation
  -   Testing infrastructure



  This project is in experimental phase and we welcome feedback and contributions:

  1. Fork the repository
  2. Create a feature branch
  3. Make your changes
  4. Run tests: `pytest`
  5. Submit a pull request



  MIT License - see LICENSE file for details


pkgId: 65f0fca71ebfdeb6110db70920277c558c6c167a54fb64dd6967c4d9cc3c00f0
name: python-mashlib-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for mashlib
url: https://github.com/moonshinelabs-ai/mash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mashlib-0.1.8-1.src.rpm
location_href: Packages/python-mashlib-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  <br />
  <p align="center">
      <a href="https://github.com/moonshinelabs-ai/moonshine">
        <img src="https://moonshine-assets.s3.us-west-2.amazonaws.com/mash_full_logo_light.png" width="50%"/>
      </a>
  </p>

  <h2><p align="center">Shared utility functions powering Moonshine tools.</p></h2>

  <p align="center">
      <a href="https://moonshine-mash.readthedocs.io/en/latest/">
          <img alt="Documentation" src="https://readthedocs.org/projects/moonshine-mash/badge/?version=latest">
      </a>
      <a href="https://pypi.org/project/moonshinelabs-ai/">
          <img alt="PyPi Version" src="https://img.shields.io/pypi/pyversions/mashlib">
      </a>
      <a href="https://pypi.org/project/mashlib/">
          <img alt="PyPi Package Version" src="https://img.shields.io/pypi/v/mashlib">
      </a>
      <a href="https://pepy.tech/project/mashlib/">
          <img alt="PyPi Downloads" src="https://static.pepy.tech/personalized-badge/mashlib?period=month&units=international_system&left_color=grey&right_color=blue&left_text=Downloads/month">
      </a>
      <a href="https://join.slack.com/t/moonshinecommunity/shared_invite/zt-1rg1vnvmt-pleUR7TducaDiAhcmnqAQQ">
          <img alt="Chat on Slack" src="https://img.shields.io/badge/slack-chat-2eb67d.svg?logo=slack">
      </a>
      <a href="https://github.com/moonshinelabs-ai/moonshine/blob/main/LICENSE">
          <img alt="License" src="https://img.shields.io/badge/license-MIT-green">
      </a>
  </p>
  <br />


  Mash is a straightforward utility library for common tasks in computer vision and deep model training. The library was broken out of previous Moonshine projects like Moonshine and Zeroshot.


  Mash broadly supports a few utilities, but the main ones are:

  1. Easy image conversion: simply call `to_pil`, `to_numpy`, and `to_tensor` to convert image formats. Accepts other images, URLs, or local files.
  2. Image processing files: convenience functions like `crop_to_multiple_of_dimensions` for transformer based patch models like ViT.
  3. Console UI: for long running jobs, a fullscreen console utility that has a progress bar at the bottom and text logging.
  4. Cloud functions: use `glob` or `exists` on AWS or GCS links.

  For a complete list of functions, see [the documentation](https://moonshine-mash.readthedocs.io/en/latest/index.html)


  To install via pip:

  `pip install mashlib`


  To use:

  ```python

  import mash


  import mash.images as mi
  image = mi.to_numpy("/path/to/image.png")
  ```


pkgId: 344c72f50197397671e1479fefe9e78df0662244beb00610ada7cac00f156f9e
name: python-mashpit-help
arch: noarch
version: 0.9.10
epoch: 0
release: 1
summary: Development documents and examples for mashpit
url: https://pypi.org/project/mashpit/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mashpit-0.9.10-1.src.rpm
location_href: Packages/python-mashpit-help-0.9.10-1.noarch.rpm
checksum_type: sha256
description:
  SAMN24804945 | ... | PDS000111028.1|GCA_022617975.1|1|...|
  SAMEA8998150 | ... | PDS000111027.1|GCA_021238725.1|0.927|...|
  In this example, the SNP cluster PDS000111028.1 is the most similar to the query genome GCA_022617975.1 with a similarity score of 1. The SNP cluster PDS000111027.1 is the second most similar with a similarity score of 0.927.




  ```
  usage: mashpit build [-h] [--quiet] [--number NUMBER] [--ksize KSIZE] [--species SPECIES] [--email EMAIL] [--key KEY] [--pd_version PD_VERSION] [--list LIST] {taxon,accession} name
  positional arguments:
    {taxon,accession}     mashpit database type
    name                  mashpit database name
  optional arguments:
    -h, --help            show this help message and exit
    --quiet               disable logs
    --number NUMBER       maximum number of hashes for sourmash, default is 1000
    --ksize KSIZE         kmer size for sourmash, default is 31
    --species SPECIES     species name
    --email EMAIL         Entrez email
    --key KEY             Entrez api key
    --pd_version PD_VERSION
                          a specified Pathogen Detection version (PDG accession). Default is the latest.
    --list LIST           Path to a list of NCBI BioSample accessions
  ```
  - Example command
  ```
  mashpit build taxon salmonella --species Salmonella
  ```


  ```
  usage: mashpit query [-h] [--number NUMBER] [--threshold THRESHOLD] [--annotation ANNOTATION] sample database
  positional arguments:
    sample                path to query sample
    database              path to the database folder
  optional arguments:
    -h, --help            show this help message and exit
    --number NUMBER       number of isolates in the query output, default is 200
    --threshold THRESHOLD
                          minimum jaccard similarity for mashtree, default is 0.85
    --annotation ANNOTATION
                          mashtree tip annotation, default is none
  ```
  - Example command
  ```
  mashpit query sample.fasta path/to/database
  ```

  ```
  usage: mashpit update [-h] [--metadata METADATA] [--quiet] database name
  positional arguments:
    database             path for the database folder
    name                 database name
  optional arguments:
    -h, --help           show this help message and exit
    --metadata METADATA  metadata file in csv format
    --quiet              disable logs
    ```
  - Example command
  ```
  mashpit update path/to/database salmonella
  ```

  A local host webserver to run the query and visualize the output can be started using:
  ```
  mashpit webserver
  ```
  After running this command, a GUI interface will be deployed at 127.0.0.1:8080. Visit the link in your browser to start using the webserver. The webserver allows users to upload a query sample and select a database to query against. The results will be displayed in a table and a tree. A screenshot of the webserver is shown below:
  <img src="docs/img/mashpit_webserver.png" width="400">
  To note, a pre-built database is required to run the webserver. The database can be built using the `mashpit build` command.

  To contribute, please see the contributing guidelines [here](CONTRIBUTING.md).

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 2, June 1991  Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it.  (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.)  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.  To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.  Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software.  If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.  Finally, any free program is threatened constantly by software patents.  We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary.  To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.  The precise terms and conditions for copying, distribution and modification follow.  GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License.  The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  Each licensee is addressed as "you".  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.  1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.  b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.  c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.  (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.  In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:  a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  c) Accompany it with the information you received as to the offer to distribute corresponding source code.  (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)  The source code for a work means the preferred form of the work for making modifications to it.  For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable.  However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.  4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.  6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.  7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all.  For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.  10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  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 2 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, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.  Also add information on how to contact you by electronic and paper mail.  If the program is interactive, make it output a short notice like this when it starts in an interactive mode:  Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.  <signature of Ty Coon>, 1 April 1989 Ty Coon, President of Vice  This General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.


pkgId: 983381f4d35dc94f8bc256d25b16ab1c43121e69361ed5d9036c7cb203725dd2
name: python-masscube-help
arch: noarch
version: 1.1.6
epoch: 0
release: 1
summary: Development documents and examples for masscube
url: https://github.com/huaxuyu/masscube
rpm_license: CC BY-NC 4.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-masscube-1.1.6-1.src.rpm
location_href: Packages/python-masscube-help-1.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Generic badge](https://img.shields.io/badge/masscube-ver_1.0.17-%3CCOLOR%3E.svg)](https://github.com/huaxuyu/masscube/)
  ![Maintainer](https://img.shields.io/badge/maintainer-Huaxu_Yu-blue)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/bago.svg?label=PyPI%20downloads)](https://pypi.org/project/masscube/)

  **masscube** is an integrated Python package for liquid chromatography-mass spectrometry (LC-MS) data processing.

  - **Documentation:** https://huaxuyu.github.io/masscubedocs/
  - **Source code:** https://github.com/huaxuyu/masscube/
  - **Bug reports:** https://github.com/huaxuyu/masscube/issues/

  It provides:

  - High performance feature detection based on signal clustering.
  - Comprehensive feature quality evaluation.
  - Confident annotation of isotopes, adducts, and in-source fragments.
  - Ultra-fast annotation of MS/MS spectra.



  ```bash
  pip install masscube
  ```

  To upgrade **masscube** to the latest version:

  ```bash
  pip install masscube --upgrade
  ```



  Start your untargeted metabolomics data processing from [here](https://huaxuyu.github.io/masscubedocs/docs/quickstart/)



  The **masscube** project is excited to have your expertise and passion on board!

  We value all enhancements or corrections. For those thinking about making significant contributions to the codebase, we encourage you to get in touch with us!

  - Huaxu Yu, hxuyu@ucdavis.edu


pkgId: 64d2df96126a1873a9f1ee3d6037eebf7788922b7c53eae2d4a12b7508faf35d
name: python-mastapy-help
arch: noarch
version: 14.0.3
epoch: 0
release: 1
summary: Development documents and examples for mastapy
url: https://www.smartmt.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mastapy-14.0.3-1.src.rpm
location_href: Packages/python-mastapy-help-14.0.3-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
  <img src="https://documentation.smartmt.com/MastaAPI/14.0.3/images/smt_logo.png" width="150" alt="SMT"><br>
  <img src="https://documentation.smartmt.com/MastaAPI/14.0.3/images/MASTA_14_logo.png" width="400" alt="Mastapy">
  </h1><br>

  [![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) [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  Mastapy is the Python scripting API for MASTA.

  - **Website**: https://www.smartmt.com/
  - **Support**: https://support.smartmt.com/
  - **Documentation**: https://documentation.smartmt.com/MastaAPI/14.0.3/




  - Powerful integration with MASTA with the ability to run Python scripts from the MASTA interface directly.
  - Ability to use MASTA functionality external to the MASTA software in an independent script.
  - An up-to-date and tight integration with Python. This is not a lightweight wrapper around the C# API. It is specifically designed for Python and works great in tandem with other common scientific Python packages (e.g. SciPy, NumPy, Pandas, Matplotlib, Seaborn, etc.)
  - Extensive backwards compatibility support. Scripts written in older versions of mastapy will still work with new versions of MASTA.
  - Full support for Linux and .NET 6 versions of the MASTA API.





  - Major performance improvements to external scripts.



  - Additional error detection and handling added to licence acquisition.
  - Small bug fixes and improvements.


pkgId: 5c9a24f3301ac7d55bda9d77337ee866926fd470029383bdff55b4b144194d7c
name: python-mastsel-help
arch: noarch
version: 1.2.17
epoch: 0
release: 1
summary: Development documents and examples for mastsel
url: https://pypi.org/project/mastsel/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mastsel-1.2.17-1.src.rpm
location_href: Packages/python-mastsel-help-1.2.17-1.noarch.rpm
checksum_type: sha256
description:
  This library was developed with 2 goals: support the Asterism Selection for
  MAVIS instrument (https://mavis-ao.org/) and managing the computation of the
  jitter (i.e. tip/tilt) error in Adaptive Optics simulations done in the Fourier
  domain. It is used by TIPTOP (https://github.com/astro-tiptop/TIPTOP).

  The main features are located in:

  - `mastsel/mavisLO.py` class that computes the jitter ellipses that can be
  - convolved with High Orders (HO, i.e. aberrations of higher spatial
  - frequencies than tip/tilt) Point Spread Functions (PSF) to get the PSFs that
  - consider both the effect of HO and Low Orders (LO, i.e. tip/tilt).

  - `mastsel/mavisPsf.py` that contains a set of methods and classes to compute
  - short and long exposure PSF from Power Spectral Densities (PSD), Strehl
  - Ratios, radial profiles, encircled energies (and other quantities) from PSF,
  - to convolve kernels with PSFs, …

  Reference: section 5 “LOW ORDER PART OF THE PSF” of Benoit et al. "TIPTOP:
  a new tool to efficiently predict your favorite AO PSF" SPIE 2020 (ARXIV:
  https://doi.org/10.48550/arXiv.2101.06486).


pkgId: db5ca6492ab6b36c7083d5772665a9d8ab26bf6ca35992346fd361ab08e4b16f
name: python-mat3ra-api-examples-help
arch: noarch
version: 2024.12.17.post0
epoch: 0
release: 1
summary: Development documents and examples for mat3ra-api-examples
url: https://pypi.org/project/mat3ra-api-examples/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mat3ra-api-examples-2024.12.17.post0-1.src.rpm
location_href: Packages/python-mat3ra-api-examples-help-2024.12.17.post0-1.noarch.rpm
checksum_type: sha256
description:
  Below, we list the contents of this repository, in roughly the order that a user might want to go through it in order to learn how our API works.

  | Folder            | Notebook                                | Description |
  | ------------------|-----------------------------------------| ----------- |
  | [Examples/System](examples/system/)     | [Get Authentication Params](examples/system/get_authentication_params.ipynb)               | Demonstrates how to programatically find your user ID and access token.
  | [Examples/Workflow](examples/workflow/) | [Get Workflows](examples/workflow/get_workflows.ipynb)                           | Walks through how to [query](https://docs.mat3ra.com/rest-api/query-structure/) the Mat3ra API to programatically search for workflows. In this example, we search for workflows that calculate the total energy of a material.
  | [Examples/Workflow](examples/workflow/) | [Quantum Espresso Workflow and Job](examples/workflow/qe_scf_calculation.ipynb)  | Create Quantum Espresso workflow starting from QE input file; create and submit job; after the job is finished, download output file, and finally perform postprocessing analysis.
  | [Examples/Material](examples/material/) | [Get Materials by Formula](examples/material/get_materials_by_formula.ipynb)                | Shows how [queries](https://docs.mat3ra.com/rest-api/query-structure/) can be made to search for materials stored on your account by their formula. In this example, we search for a system containing Si.
  | [Examples/Material](examples/material/) | [Create Material](examples/material/create_material.ipynb)                         | Gives an overview of how materials can be generated in [JSON format](https://docs.mat3ra.com/materials/data/) and uploaded to your user account. In this example, we create an FCC Si crystal and upload it.
  | [Examples/Material](examples/material/) | [Import Materials from Materials Project](other/materialsproject/import_materials_from_materialsproject.ipynb) | Demonstrates how materials can be imported from [Materials Project](https://materialsproject.org/about), if their Materials Project ID is known. In this example, we import monoclinic and hexagonal SiGe cells.
  | [Examples/Material](examples/material/) | [Import Materials from Poscar](examples/material/upload_materials_from_file_poscar.ipynb)            | Provides an example of how materials can be imported directly from Poscar files (a common chemical file format best-known [for its use in VASP](https://www.vasp.at/wiki/index.php/Input)). In this example, we import the unit cell of SiGe.
  | [Examples/Job](examples/job/)            | [Create and Submit Job](examples/job/create_and_submit_job.ipynb)                   | Shows how to use the Mat3ra API to [create jobs](https://docs.mat3ra.com/jobs/data/) and run them on our cluster. In this example, we run a DFT calculation to get the total energy of an FCC Si unit cell using Quantum Espresso.
  | [Examples/Job](examples/job/)            | [Get File from Job](examples/job/get-file-from-job.ipynb) | Uses the Mat3ra API to query for a list of files produced by a job, describes the metadata assigned to each file, and ends by demonstrating how to download any remote file generated by a job to the local disk.
  | [Examples/Job](examples/job/)            | [Run Simulations and Extract Properties](examples/job/run-simulations-and-extract-properties.ipynb)  | Demonstrates copying a [bank workflow](https://docs.mat3ra.com/workflows/bank/) to an account and using it to calculate the [properties](https://docs.mat3ra.com/properties/overview/) of multiple materials. In this example, we determine the [band gap](https://docs.mat3ra.com/properties-directory/non-scalar/band-gaps/) of Si and Ge.
  | [Examples/Job](examples/job/)            | [ML - Train Model Predict Properties](examples/job/ml-train-model-predict-properties.ipynb)     | Demonstrates the  generation of a training dataset and subsequent training of a [machine learning](https://docs.mat3ra.com/software-directory/overview/#machine-learning) model. In this example, we calculate the band gaps of Si and SiGe, and using various materials properties as descriptors, train a model to predict their band gaps. Finally, we use this trained model to predict the band gap of Ge.





  NOTE: tested with Python version 3.8 and 3.10, please assert that the virtual environment is created with it. Use [`pyenv`](https://github.com/pyenv/pyenv#installation) to manage Python versions.

  Follow the steps below in order to setup and view the Jupyter notebooks:

  0. [Install git-lfs](https://help.github.com/articles/installing-git-large-file-storage/) [[3](#links)] in order to get access to the source code and notebook files.

  1. Clone repository:

      ```bash
      git clone https://github.com/Exabyte-io/api-examples.git
      ```

      Or, if you have set up SSH keys

      ```bash
      git clone git@github.com:Exabyte-io/api-examples.git
      ```

      In case for some reason git-lfs was not installed at the time of cloning, the files can be pulled after installing git-lfs, through `git lfs pull`.

      Related to this, please be aware that as the `.ipynb` and `.poscar` files are stored on git-lfs, they are not part of the zip archive downloaded through GitHub's web interface.

  3. Install [virtualenv](https://virtualenv.pypa.io/en/stable/) using [pip](https://pip.pypa.io/en/stable/) if not already present:

      ```bash
      pip install virtualenv
      ```

  4. Create virtual environment and install required packages:

      ```bash
      cd api-examples
      virtualenv .env
      source .env/bin/activate
      pip install -e ."[localhost]"
      ```

  5. Run Jupyter and open a notebook in a browser. In order for the post-save hook feature to work properly, one must launch their Jupyter Notebook environment in the folder that contains the file `config.py`, which is the `examples` folder shown below:

      ```bash
      cd examples
      jupyter lab --config=config.py
      ```



  In order to run or edit the examples:

  1. Assert an existing Mat3ra.com account. Examples require an account to run. New users can register [here](https://platform.mat3ra.com/register) to obtain one.

  2. Open [settings](utils/settings.json) and adjust it to provide the API authentication parameters. See the [corresponding example](examples/system/get_authentication_params.ipynb) to learn how to obtain the authentication parameters. It is also possible to generate an API token by logging in to [Mat3ra platform](https://platform.mat3ra.com/), navigating to the Account Preferences, and clicking the 'Generate new token' button under API Tokens. More details can be found [here](https://docs.mat3ra.com/accounts/ui/preferences/api/).

  3. Open the desired example notebook, adjust it as necessary and run. One can speed up the notebooks execution after running the [Get Authentication Params](examples/system/get_authentication_params.ipynb) one by reusing the kernel from the first notebook.

    <img src="images/reusable-kernel.png" width="250px" />

  NOTE: The Materials Project API key should be obtained from [https://legacy.materialsproject.org/open](https://legacy.materialsproject.org/open).




  This is an open-source repository and we welcome contributions for other use cases. The original set of examples is only meant to demonstrate the capabilities and can be extended.

  We suggest forking this repository and introducing the adjustments there. The changes in the fork can further be considered for merging into this repository as it is commonly used on GitHub. This process is explained in more details elsewhere online [[4](#links)].

  If you would like to add new examples or adjust existing ones, please consider the following:

  1. Put examples into the corresponding directories by domain.

  2. Walk the readers through the examples by providing step-by-step explanation similar to [this](examples/material/get_materials_by_formula.ipynb) example.

  3. We use post-save hooks to automatically convert notebooks to python scripts. See [config](examples/config.py) file for more information. In order to facilitate code review, we exclude notebook sources in the `other/` directory from version control and store them in Git LFS [[3](#links)]. Please follow this convention.

  4. Apply code formatting by installing development requirements as follows:

      ```bash
      pip install -e ."[dev]"
      pre-commit install
      pre-commit run --all-files
      ```

      Check more details about `pre-commit` [here](https://pre-commit.com/).



  1. Mat3ra.com RESTful API, description in the online documentation: [link](https://docs.mat3ra.com/rest-api/overview/)
  2. Jupyter.org, official website: [link](https://jupyter.org/)
  3. Git Large File Storage, official website: [link](https://git-lfs.github.com/)
  4. GitHub Standard Fork & Pull Request Workflow, online explanation: [link](https://gist.github.com/Chaser324/ce0505fbed06b947d962)


pkgId: 5e3d99ed0ab3d5f1e1686e658ad6a7ca9c28c58b6a59e4af2a1aaa24f5012a01
name: python-mat3ra-esse-help
arch: noarch
version: 2024.12.19.post0
epoch: 0
release: 1
summary: Development documents and examples for mat3ra-esse
url: https://pypi.org/project/mat3ra-esse/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mat3ra-esse-2024.12.19.post0-1.src.rpm
location_href: Packages/python-mat3ra-esse-help-2024.12.19.post0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/mat3ra-esse.svg)](https://badge.fury.io/py/mat3ra-esse)
  [![npm version](https://badge.fury.io/js/@mat3ra%2Fesse.svg)](https://badge.fury.io/js/@mat3ra%2Fesse)
  [![License: Apache](https://img.shields.io/badge/License-Apache-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  Essential Source of Schemas and Examples (ESSE) contains data format definitions (schemas) and examples for common entities used in digital materials science (see refs. [^1], [^2] below).

  Although the schemas are used to facilitate the operations of [mat3ra.com](https://mat3ra.com), they are designed to be generic and can be used in other applications. The open-source packages developed by Mat3ra.com use the schemas available in this repository.

  The latest variants of schemas and examples are available at [schemas.mat3ra.com](https://schemas.mat3ra.com/).

  ESSE has a dual-nature as both a Python and a Node.js package.





  ESSE is compatible with Python 3.8+.



  ```bash
  pip install mat3ra-esse
  ```



  ```bash
  virtualenv .venv
  source .venv/bin/activate
  pip install -e PATH_TO_ESSE_REPOSITORY
  ```





  ```bash
  npm install @mat3ra/esse
  ```



  ESSE contains separate but equivalent interfaces for Python and Javascript.
  The package provides `ESSE` class that can be initialized and used as below.



  ```python
  from mat3ra.esse import ESSE

  helper = ESSE()
  schema = helper.get_schema_by_id("material")
  ```



  ```javascript
  const { ESSE } = require("@mat3ra/esse/lib/js/esse");

  const helper = new ESSE();
  const schema = helper.getSchemaById("material");
  ```



  ESSE contains 3 main directories, [schema](schema), [example](example) and [src](src) outlined below.



  The schema directory contains the schemas specifying the rules to structure data. A set of core schemas, outlined below, are defined to facilitate the schema modularity.

  - [Primitive](schema/core/primitive) directory contains a set of custom primitives that extends default standard primitive types allowed by schema, such as String and Number.
  Primitives are solely defined by the default primitives and can not be re-constructed from each other.
  - [Abstract](schema/core/abstract) directory contains unit-less schemas that are constructed from default and custom primitives.
  - [Reusable](schema/core/reusable) directory contains the schemas that are widely used in other schemas to avoid duplication, constructed from the abstract and primitive schemas.
  - [Reference](schema/core/reference) directory contains the schemas defining the rules to structure the references to data sources.



  This directory contains the examples formed according to the schemas and implements the same directory structure as the schema directory.



  This directory contains Python and Javascript interfaces implementing the functionality to access and validate schemas and examples.





  Generative keys are the fields which allow for user input prior to calculation of the final property values. A flag is included in the schema comments on the fields in [property schemas](schema/properties_directory): `isGenerative:true` marks which fields to use as subschemas in the generation of a user input schema. On properties allowing user inputs, additional fields may be tagged, as in [the `file_content` property](schema/properties_directory/non-scalar/file_content.json)



  The schemas and examples are stored as JSON assets. The JSON assets are used to generate JS/TS and PY modules that can be used to access the schemas and examples in the corresponding runtimes. The modules are generated using the [build_schemas.py](./build_schemas.py) and [build_schema.js](./build_schema.js) scripts. The JS modules are generated during the transpilation step of the npm. The PY modules are generated during the development and distributed within the pip package.

  The following outlines the development process workflow:

  1. Setup: clone the repository and install the dependencies for both JS and PY (as explained below).
  2. Edit code and commit changes.
  3. Pre commit is used to regenerate the modules.
  4. Push the changes to GitHub.
  5. GH workflow is used to generate the fully resolved file (without "$ref"s and "$allOf" etc.) and examples and publish them to [schemas.mat3ra.com](http://schemas.mat3ra.com/).
  6. Publish the new version of the package to PyPI and npm.

  The [pre-commit](.husky/pre-commit) is using both JS and PY runtime(s) to regenerate the schemas and examples.

  [//]: # (TODO: consider reusing JS runtime and schemas build script for PY modules for consistency)
  NOTE: The PY and JS modules are built from the same JSON sources, but using different runtimes (scripts) and thus may still be different. Only for JS the fully resolved schemas (with merged "$allOf") are created. They are used for the docs website.



  When developing in python the following should be taken into account:

  1. The modules containing the schemas and examples are generated using the [build-schemas.py](./build_schemas.py) script. There is a setup for it to be run automatically on every commit, but it is recommended to run it manually before committing to make sure that the changes are reflected in the modules. This can be done with `pre-commit run --all-files`. The pre-commit package can be installed with `pip install pre-commit`. To rebuild schemas manually, run (note `-e` in install):

      ```bash
      virtualenv .venv
      source .venv/bin/activate
      pip install -e ."[tests]"
      pip install pre-commit
      pre-commit --install
      git config --unset-all core.hooksPath
      python build_schemas.py
      ```

  2. Tests can be run using the following commands:

      ```bash
      virtualenv .venv
      source .venv/bin/activate
      pip install ."[tests]"
      python -m unittest discover --verbose --catch --start-directory tests/py/esse/
      ```



  See [package.json](package.json) for the list of available npm commands. The JS modules are generated using the [build_schema.js](./build_schema.js) script. There is a setup for it to be run automatically when the package is installed (see "transpile" directive). To rebuild schemas manually, run:

  ```bash
  npm install
  npm run transpile
  ```



  This repository is an [open-source](LICENSE.md) work-in-progress and we welcome contributions. We suggest forking this repository and introducing the adjustments there, the changes in the fork can further be considered for merging into this repository as it is commonly done on GitHub (see [^3] below).

  Other suggestions:

  - Use unique IDs for schemas
  - Do not use circular references in the schemas, instead leave the type as object and add explanation to description.



  [^1]: [Data-centric online ecosystem for digital materials science](https://arxiv.org/pdf/1902.10838.pdf)
  [^2]: [CateCom: A Practical Data-Centric Approach to Categorization of Computational Models](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.2c00112)
  [^3]: [GitHub Standard Fork & Pull Request Workflow](https://gist.github.com/Chaser324/ce0505fbed06b947d962)

rpm_license:
  # LICENSE  Copyright 2019 Exabyte Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: a7b3023f82292f95d99bfc961ae5b9cf2275ce45fb53bdf7470ef0dc797d8701
name: python-mat3ra-made-help
arch: noarch
version: 2024.12.17.post0
epoch: 0
release: 1
summary: Development documents and examples for mat3ra-made
url: https://pypi.org/project/mat3ra-made/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mat3ra-made-2024.12.17.post0-1.src.rpm
location_href: Packages/python-mat3ra-made-help-2024.12.17.post0-1.noarch.rpm
checksum_type: sha256
description:
  [![npm version](https://badge.fury.io/js/%40mat3ra%2Fmade.svg)](https://badge.fury.io/js/%40mat3ra%2Fmade)
  [![License: Apache](https://img.shields.io/badge/License-Apache-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  Made is a library for **MA**terials **DE**sign. It allows for creating and manipulating material structures from atoms up. The library is aimed to be used for the development of web applications, both on the client (web browser) and server (eg. Node.js) side. It has implementations in Python (including Pyodide) and JavaScript/TypeScript.



  The package provides software concepts for interacting with Materials-related data structures. The concepts follow the ESSE Data Convention [[1]](#links).





  From NPM for use within a software project:

  ```bash
  npm install @mat3ra/made

  ```



  From PyPI for use within a software project:

  ```bash
  pip install mat3ra-made
  ```

  When willing to use the optional `tools` module, install the package with the following command:

  ```bash
  pip install "mat3ra-made[tools]"
  ```




  As below

  - High-level classes for the representation of the [Material](src/material.js) and the corresponding structural information, ie:
      - [Basis](src/basis/basis.js),
      - [Lattice](src/lattice/lattice.js),
      - [ReciprocalLattice](src/lattice/reciprocal/lattice_reciprocal.js),
      - [Cell](src/cell/cell.js),
      - [AtomicConstraints](src/constraints/constraints.js)
      - and others to be added.
  - input/output support, including:
      - POSCAR [[3]](#links),
      - XYZ [[4]](#links),
      - Quantum ESPRESSO [[5]](#links),
      - and others to be added.
  - structural generation and analysis tools:
      - [supercell](src/tools/supercell.js)
      - [surfaces](src/tools/surface.js)
      - [combinatorial sets](src/parsers/xyz_combinatorial_basis.js)
      - [interpolated sets for chemical reactions](src/tools/basis.js)




  This repository is an [open-source](LICENSE.md) work-in-progress and we welcome contributions.

  We regularly deploy the latest code containing all accepted contributions online as part of the [Mat3ra.com](https://mat3ra.com) platform, so contributors will see their code in action there.

  We suggest forking this repository and introducing the adjustments there to be considered for merging into this repository as explained in more details [here](https://gist.github.com/Chaser324/ce0505fbed06b947d962), for example.



  Object-oriented design patterns encapsulate key concepts following the conventions below.

  1. Classes follow the Exabyte Data Convention and data structures defined in ESSE [[1]](#links)

  2. Only materials-related code is considered. Properties related to [simulation model](https://docs.exabyte.io/models/overview/) parameters (eg. type of approximation, numerical parameters) shall go elsewhere.

  3. `tools` directory contains helper functions that act on one or more classes and include an external parameter. Functions that use class data without any external parameters should be implemented inside the class. For example, `basis.clone()` is implemented in `Basis`, but basis repetition is implemented as a tool in the correspondingly named function ([tools/basis.js#repeat](src/tools/basis.js)) because the repetion requires a parameter external to basis - number of repetitions in 3 spatial dimensions.

  4. [Deprecated, use mat3ra-parsers or @mat3ra/parsers] `parsers` directory contains the parsers to- and from- ESSE format mentioned in 1. All functionality related to external data conversion is contained in this directory.




  [Outdated] Desirable features for implementation:

  - identify primitive / conventional structures
  - support for molecular geometries
  - support for polymer geometries
  - radial correlation function calculation
  - generation of complex atomic shapes:
      - fullerene
      - nanotube
      - nanowire
      - nano-cluster
      - a combination of the above
      - arbitrary atomic arrangement







  Made tests are written based on Mocha [6](#links) testing framework and can be executed as follows.

  ```bash
  git pull
  git lfs pull
  ```
  to get the latest test fixtures from LFS, and then:

  ```bash
  npm install
  npm test
  ```



  1. Keep the tests directory structure similar to the main codebase directory structure. Every JS module in the main codebase should have a corresponding module in tests directory which implements the tests for provided functionality.

  2. Add tests fixtures into [fixtures](./tests/fixtures) directory. The fixtures are automatically stored on Git LFS [7](#links).

  3. If the fixtures are going to be used inside multiple cases, read and export them inside [enums](./tests/enums.js) to avoid code duplicates.

  4. [Tests setup module](./tests/setup.js) can be used to implement the hooks that are used to prepare the tests environment.



  Linter setup will prevent committing files that don't adhere to the code standard. It will
  attempt to fix what it can automatically prior to the commit in order to reduce diff noise. This can lead to "unexpected" behavior where a
  file that is staged for commit is not identical to the file that actually gets committed. This happens
  in the `lint-staged` directive of the `package.json` file (by using a `husky` pre-commit hook). For example,
  if you add extra whitespace to a file, stage it, and try to commit it, you will see the following:

  ```bash
  ➜  made git:(feature/SOF-4398-TB) ✗ git add src/basis/constrained_basis.js
  ➜  made git:(feature/SOF-4398-TB) ✗ git commit -m "Test commit non-linted code"
  ✔ Preparing...
  ✔ Running tasks...
  ✖ Prevented an empty git commit!
  ✔ Reverting to original state because of errors...
  ✔ Cleaning up...

    ⚠ lint-staged prevented an empty git commit.
    Use the --allow-empty option to continue, or check your task configuration

  husky - pre-commit hook exited with code 1 (error)
  ```

  The staged change may remain but will not have been committed. Then it will look like you still have a staged
  change to commit, but the pre-commit hook will not actually commit it for you, quite frustrating! Styling can
  be applied manually and fixed by running:

  ```bash
  npm run lint:fix
  ```

  In which case, you may need to then add the linter edits to your staging, which in the example above, puts the
  file back to identical with the base branch, resulting in no staged changes whatsoever.



  In order for the WebStorm IDE to take full advantage of the linting configuration, it can be configured in the project:

  - `Preferences -> Languages & Frameworks -> JavaScript -> Code Quality Tools -> ESLint`
  - Check `Automatic ESLint configuration` which should infer all the configurations from the project directory





  Python 3.8+ is required to run the tests. We recommend using PyEnv to manage Python versions. Tests are written based on PyTest and can be executed as follows.

  ```bash
  virtualenv .venv
  source .venv/bin/activate
  pip install ".[tests]"
  pytest tests/py
  ```



  Conventions:

  - The "tools" module has external dependencies on "pymatgen" and "ase" packages and so is meant as optional. When implementing new functionality, the use of ASE is recommended over pymatgen for compatibility purposes.



  To build and serve locally, use the following command:

  ```bash
  wheel_server
  ```
  More details can be found in the [script documentation](https://github.com/Exabyte-io/utils/blob/main/README.md).





  To be added.



  As below:

  - Python 3.8 tests are failing on Apple Silicon due to https://github.com/materialsproject/pymatgen/issues/3521



  1. [Exabyte Source of Schemas and Examples (ESSE), Github Repository](https://github.com/exabyte-io/exabyte-esse)
  2. [ECMAScript 2015 Language Specifications](https://www.ecma-international.org/ecma-262/6.0/)
  3. [POSCAR file format, official website](https://cms.mpi.univie.ac.at/vasp/guide/node59.html)
  4. [XYZ file format, Wikipedia](https://en.wikipedia.org/wiki/XYZ_file_format)
  5. [Quantum ESPRESSO, Official Website](https://www.quantum-espresso.org/)
  6. [Mocha, Official Website](https://mochajs.org/)
  7. [Git LFS, Official Website](https://git-lfs.github.com/)

rpm_license:
  # LICENSE  Copyright 2019 Exabyte Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: a1ee65c46cc04bb1336c487fed2a471f5d127eec7c436d97978922ae2c6334bc
name: python-mat3ra-standata-help
arch: noarch
version: 2024.12.19.post1
epoch: 0
release: 1
summary: Development documents and examples for mat3ra-standata
url: https://pypi.org/project/mat3ra-standata/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mat3ra-standata-2024.12.19.post1-1.src.rpm
location_href: Packages/python-mat3ra-standata-help-2024.12.19.post1-1.noarch.rpm
checksum_type: sha256
description:
  Standard data for digital materials R&D entities in the [ESSE](https://github.com/Exabyte-io/esse) data format.





  The package is compatible with Python 3.10+. It can be installed as a Python package either via PyPI:

  ```shell
  pip install mat3ra-standata
  ```

  Or as an editable local installation in a virtual environment after cloning the repository:

  ```shell
  virtualenv .venv
  source .venv/bin/activate
  pip install -e PATH_TO_STANDATA_REPOSITORY
  ```



  Standata can be installed as a Node.js package via NPM (node package manager).

  ```shell
  npm install @mat3ra/standata
  ```





  ```python
  from mat3ra.standata.materials import materials_data

  materialConfigs = materials_data["filesMapByName"].values();
  ```



  ```javascript
  // Direct import can be used to avoid importing all data at once.
  import data from "@mat3ra/standata/lib/runtime_data/materials";
  // This creates a list of JSON configs for all materials.
  const materialConfigs = Object.values(data.filesMapByName);
  ```





  To avoid file system calls on the client, the entity categories and data structures are made available at runtime via
  the files in `src/js/runtime_data`. These files are generated automatically using the following command:

  ```shell
  npm run build:runtime-data
  ```





  The Python package adds a command line script `create-symlinks` that creates a category-based file tree where
  entity data files are symbolically linked in directories named after the categories associated with the entity.
  The resulting file tree will be contained in a directory names `by_category`.
  The script expects the (relative or absolute) path to an entity config file (`categories.yml`). The destination
  of the file tree can be modified by passing the `--destination`/`-d` option.

  ```shell

  create-symlinks --help

  create-symlinks materials/categories.yml

  create-symlinks materials/categories.yml -d tmp
  ```



  Analogous to the command line script in Python, the repository also features a script in
  TypeScript (`src/js/cli.ts`) and (after transpiling) in JavaScript (`lib/cli.js`).
  The script takes the entity config file as a mandatory positional argument and the
  alternative location for the directory containing the symbolic links (`--destination`/`-d`).

  ```shell

  node lib/cli.js materials/categories.yml

  ts-node src/js/cli.ts materials/categories.yml

  ts-node src/js/cli.ts -d tmp materials/categories.yml

  npm run build:categories -- materials/categories.yml
  ```



  See [ESSE](https://github.com/Exabyte-io/esse) for the notes about development and testing.

  To develop, first, create a virtual environment and install the dev dependencies:

  ```shell
  python -m venv .venv
  source .venv/bin/activate
  pip install ".[dev]"
  ```



  The materials data is sourced from the [Materials Project](https://next-gen.materialsproject.org) for 3D materials and [2dmatpedia](http://www.2dmatpedia.org) for 2D materials. The structural data in POSCAR format is stored in the `materials/sources` directory alongside the `manifest.yml` file that contains the additional description and metadata for each material.

  To add new materials to Standata, place the POSCAR file in the `materials/sources` directory and update the `manifest.yml` file with the new material's metadata. Then run to create the materials data:

  ```shell
  python create_materials.py
  ```



  Our dataset's naming convention for materials is designed to provide a comprehensive description of each material, incorporating essential attributes such as chemical composition, common name, crystal structure, and unique identifiers.



  The format for the material name property is a structured representation that includes the chemical formula, common name, crystal system, space group, dimensionality, specific structure details, and a unique identifier. Each element in the name is separated by a comma and space.

  Format:

  ```
  {Chemical Formula}, {Common Name}, {Crystal System} ({Space Group}) {Dimensionality} ({Structure Detail}), {Unique Identifier}
  ```

  **Examples**:

  - Ni, Nickel, FCC (Fm-3m) 3D (Bulk), mp-23
  - ZrO2, Zirconium Dioxide, MCL (P2_1/c) 3D (Bulk), mp-2858
  - C, Graphite, HEX (P6_3/mmc) 3D (Bulk), mp-48
  - C, Graphene, HEX (P6/mmm) 2D (Monolayer), mp-1040425



  Filenames are derived from the name property through a slugification process, ensuring they are filesystem-friendly and easily accessible via URLs or command-line interfaces. This process involves converting the structured name into a standardized, URL-safe format that reflects the material's attributes.

  Format:

  ```
  {Chemical_Formula}-[{Common_Name}]-{Crystal_System}_[{Space_Group}]_
  {Dimensionality}_[{Structure_Detail}]-[{Unique_Identifier}]
  ```

  **Transformation Rules**:

  Commas and Spaces: Replace `, ` (comma and space) with `-` (hyphen) and ` ` (space) with `_` (underscore).
  Parentheses: Convert `(` and `)` into `[` and `]` respectively.
  Special Characters: Encode characters such as `/` into URL-safe representations (e.g., `%2F`).
  Brackets: Wrap common name and identifier parts in square brackets `[]`.

  **Filename Examples**:

  - Ni-[Nickel]-FCC_[Fm-3m]_3D_[Bulk]-[mp-23]
  - ZrO2-[Zirconium_Dioxide]-MCL_[P2_1%2Fc]_3D_[Bulk]-[mp-2858]
  - C-[Graphite]-HEX_[P6_3%2Fmmc]_3D_[Bulk]-[mp-48]
  - C-[Graphene]-HEX_[P6%2Fmmm]_2D_[Monolayer]-[mp-1040425]

rpm_license:
  # LICENSE  Copyright 2023 Exabyte Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: f6b78528288d12a907d828235120e28f8e62a223c00d97496321a9ee40783e4f
name: python-mate-cxinsys-help
arch: noarch
version: 0.1.15
epoch: 0
release: 1
summary: Development documents and examples for mate-cxinsys
url: https://github.com/cxinsys/mate
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mate-cxinsys-0.1.15-1.src.rpm
location_href: Packages/python-mate-cxinsys-help-0.1.15-1.noarch.rpm
checksum_type: sha256
description:
  - **MATE** represents **M**anycore-processor-**A**ccelerated **T**ransfer **E**ntropy computation.



  - :snake: [Anaconda](https://www.anaconda.com) is recommended to use and develop MATE.
  - :penguin: Linux distros are tested and recommended to use and develop MATE.


  First, clone the recent version of this repository.

  ```
  git clone https://github.com/cxinsys/mate
  ```


  Now, we need to install MATE as a module.

  ```
  cd mate
  pip install -e .
  ```
  <br>

  - Default backend framework of the 'MATE' class is PyTorch.
  - **[recommended]** To use PyTorch Lightning framework, you need to use a another class called 'MATELightning' (see [MATELightning class](#MATELightning-class))

  <br>



  MATE supports several optional backend frameworks such as CuPy and JAX. \
  To use optional frameworks, you need to install the framework manually

  <br>

  - CuPy: [Installing CuPy from Conda-Forge with cudatoolkit](https://docs.cupy.dev/en/stable/install.html#installing-cupy-from-conda-forge)

  Install Cupy from Conda-Forge with cudatoolkit supported by your driver
  ```angular2html
  conda install -c conda-forge cupy cuda-version=xx.x (check your CUDA version)
  ```
  <br>

  - JAX: [Installing JAX refer to the installation guide in the project README](https://github.com/google/jax#installation)

  [//]: # (**You must first install [CUDA]&#40;https://developer.nvidia.com/cuda-downloads&#41; and [CuDNN]&#40;https://developer.nvidia.com/cudnn&#41; before installing JAX**)

  [//]: # ()
  [//]: # (After install CUDA and CuDNN you can specify a particular CUDA and CuDNN version for jax explicitly)
  Install JAX with CUDA > 12.x
  ```angular2html
  pip install -U "jax[cuda12]"
  ```

  <br>

  - TensorFlow: [Installing TensorFlow refer to the installation guide](https://www.tensorflow.org/install/pip?hl=en#linux)

  [//]: # (**You must first install [CUDA]&#40;https://developer.nvidia.com/cuda-downloads&#41; and [CuDNN]&#40;https://developer.nvidia.com/cudnn&#41; before installing JAX**)

  [//]: # ()
  [//]: # (After install CUDA and CuDNN you can specify a particular CUDA and CuDNN version for jax explicitly)
  Install TensorFlow-GPU with CUDA
  ```angular2html
  python3 -m pip install tensorflow[and-cuda]
  ```

  <br>







  ```angular2html
  import mate

  worker = mate.MATE()
  ```






  [//]: # (MATE goes through a binning process, which is sensitive to noise. )

  [//]: # (To work around this, you can use a smooth function like )

  [//]: # (scipy's [savgol_filter]&#40;https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.savgol_filter.html#scipy-signal-savgol-filter&#41;.)

  - **arr**: numpy array for transfer entropy calculation, required
  - **pair**: numpy array for calculation pairs, optional, default: compute possible pairs from all nodes in the arr
  - **backend**: optional, default: 'cpu'
  - **device_ids**: optional, default: [0] (cpu), [list of whole gpu devices] (gpu)
  - **procs_per_device**: The number of processes to create per device when using non 'cpu' devices, optional, default: 1
  - **batch_size**: required
  - **kp**: kernel percentile, optional, default: 0.5
  - **df**: history length, optional, default: 1


  ```angular2html
  result_matrix = worker.run(arr=arr,
                             pairs=pairs,
                             backend=backend,
                             device_ids=device_ids,
                             procs_per_device=procs_per_device,
                             batch_size=batch_size,
                             kp=kp,
                             dt=dt,
                             )
  ```







  - **arr**: numpy array for transfer entropy calculation, required
  - **pair**: numpy array for calculation pairs, optional, default: compute possible pairs from all nodes in the arr
  - **kp**: kernel percentile, optional, default: 0.5
  - **len_time**: total length of expression array, optional, default: column length of array
  - **dt**: history length of expression array, optional, default: 1

  ```angular2html
  import mate

  worker = mate.MATELightning(arr=arr,
                              pairs=pairs,
                              kp=kp,
                              len_time=len_time,
                              dt=dt)
  ```
  <br>




  MATELightning's run function parameters take the same values as [PyTorch's DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)
  and [PyTorch Lightning's Trainer](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.trainer.trainer.Trainer.html#trainer).
  For additional options for parameters, see those documents

  - **backend**: required, 'gpu', 'cpu' or 'tpu' etc
  - **devices**: required, int or [list of device id]
  - **batch_size**: required
  - **num_workers**: optional, default: 0
  ```angular2html
  result_matrix = worker.run(backend=backend,
                             devices=devices,
                             batch_size=batch_size,
                             num_worker=num_worker)
  ```

  <br>



  - [x] add 'jax' backend module
  - [x] implement 'pytorch lightning' backend module
  - [x] add 'tensorflow' backend module


pkgId: c18d16469703ed5e820f743213006d91511041c7cc6a8a69eb10abd7b805c157
name: python-math-spec-mapping-help
arch: noarch
version: 0.3.19
epoch: 0
release: 1
summary: Development documents and examples for math-spec-mapping
url: https://pypi.org/project/math-spec-mapping/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-math-spec-mapping-0.3.19-1.src.rpm
location_href: Packages/python-math-spec-mapping-help-0.3.19-1.noarch.rpm
checksum_type: sha256
description:
  MSML is a library for standardizing the creation of mathematical specifications as JSON objects as well as aiding in the automation of report and visualization creation from these standardized JSON.

  It uses block diagram wirings and spaces to represent the actions in complex systems in line with current BlockScience research on Generalized Dynamical Systems. It also adds some enhancements to the primitive blocks to represent richer sets of behaviors.

  One good example is the [wiring report](https://github.com/SeanMcOwen/Root-Finding-Simulation/blob/main/MSML/reports/Simulation%20Block.md) for the Root Finding Simulation canonical example.



  To install the library, simply pip install by running "pip install math_spec_mapping"



  Writing mathematical specifications can be a difficult process, especially when variable names are changed or new mechanisms are introduced. MSML seeks to streamline the process with automations as well as enhance the abilities of static math specs to deliver deeper insights. Because it is automated, one can write specifications at different levels of details or for different purposes.




  - **Automation**: Automate writing of a specification
  - **Standardization**: Ensure standardization across teams working to spec out a system
  - **Flexibility**: Allow for creating views on the fly and in multiple ways depending on what stakeholders find important
  - **Trackability**: Keep a repository of a JSON file to track changes to the spec with the same enhancements git provides for projects already




  ```mermaid
  graph TD
  A[JSON Object \n\n Each spec has a repo for tracking changes \n Must conform to the json specification \n Defines all aspects of the spec including blocks, spaces and actions] -->B[MSML Object \n\n JSON file is parsed, with validations and mappings along the way \n Can show different views on the fly]
      B --> C[Report Outputs & Obsidian Directory \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ\n Also builds an entire Obsidian directory of all components as linked notes]
  D[Python Function Implementations \n\n Optional enhancement to actually execute code\n Done for each referenced policy option, mechanism, etc. \n Just needs a function definition for each] --> B
  B --> E[Python Wirings & Simulations \n\n MSML can be used to run blocks \n Wirings automatically work to pass between domain/codomains \n Entire simulations can be built up as composed wirings]
  ```



  The engineering lifecycle as defined and visualized in ["Block by Block: Managing Complexity with Model-Based Systems Engineering"
  ](https://blog.block.science/block-by-block-managing-complexity-with-model-based-systems-engineering/) is depicted below.

  ![Systems Engineering Diagram](SystemsEngineering.png)

  MSML can aid in all five of these phases in different ways.



  During ideation phases, users of MSML can leverage the markdown writing tool to begin organizing different thoughts into components. For example, if one were trying to model a system that has multiple currencies, i.e. USD and the Euro, those could be added in as MSML types as they are discovered. The markdown report writing supports wiki-links for use in Obsidian or a similar tool allowing users to iteratively catalog different components they find in their research and ideation.



  When moving into requirements and design, MSML provides a suite of reports so that presentations to stakeholders can be insightful but tailored to the different audiences. Feedback can be iteratively incorporated into the spec with reports being re-run.



  In its basic form, a spec from MSML can be used to guide implementations because blocks can be transformed into actual code/functions and spaces act as the parameterizations of those functions. There is also experimental work being done on meta-programming so that MSML could either template simulation models or even be used to hold and write code where applicable for things such as A/B testing.



  Thanks to some of the more advanced features, MSML can be used as an aid for debugging and system validation. The functionality around seeing what parameters effect which blocks directly or downstream indirectly helps developers quickly identify root causes of issues. The linkages between mechanisms and what pieces of state they update allows for developers to quickly see all possible paths to variable changes there are in case something looks amiss.



  The ability to fork the repository of an MSML spec as well as the ability to use it for A/B testing with the policy options makes it well suited for iterating on model evolution.



  The documentation on the technical details of using the MSML can be found [here](https://github.com/BlockScience/MSML/tree/main/docs)



  [Dummy/Starter Repository](https://github.com/BlockScience/MSML/tree/main/examples/StarterRepo)
  [Root Finding Simulation](https://github.com/SeanMcOwen/Root-Finding-Simulation)



  | Feature | Dummy | Root Finding |
  | --- | --- | --- |
  | Action Transmission Channels | X | X |
  | Stack Block | X | X |
  | Parallel Block |  | X |
  | Split Block |  |  |
  | Boundary Actions | X |  |
  | Control Actions | X | X |
  | Entities | X |  |
  | Mechanisms | X | X |
  | Parameters | X | X |
  | Policies | X | X |
  | Spaces | X | X |
  | State | X | X |
  | Stateful Metrics |  |  |
  | State Update Transmission Channels | X | X |
  | Reports | X | X |



  [GDS-MSML-cadCAD Repository](https://github.com/BlockScience/GDS-MSML-cadCAD)


pkgId: 377d045f9a4806be953b5d04e3947e5dfd72e1e65a5a9a36650f4ec2bb4d0ce4
name: python-mathalgo-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mathalgo
url: https://github.com/Donseking/MathAlgo.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mathalgo-0.1.0-1.src.rpm
location_href: Packages/python-mathalgo-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  MathAlgo 是一個專為 Python 開發者設計的模組，提供多種演算法、資料結構與數學工具，方便進行科學計算與程式開發。




  - **數學計算**：提供矩陣運算、微積分工具等。
  - **資料結構**：內建堆疊與樹狀結構模組。
  - **易於擴展**：模組化設計，方便新增自訂功能。




  以下是使用 MathAlgo 的範例：

  ```python
  from mathalgo.Math.Matrix import Matrix


  A = Matrix([[1, 2], [3, 4]])
  B = Matrix([[5, 6], [7, 8]])


  print("A + B:")
  print(A.add(B))


  print("Determinant of A:")
  print(A.determinant())

  ```



  1. 從 GitHub 複製專案：
     ```bash
     git clone https://github.com/Donseking/MathAlgo.git




  歡迎對 MyMod 提出建議或貢獻代碼！請依照以下步驟：

  1. Fork 此專案到您的 GitHub 帳戶。
  2. 創建新的分支來進行修改：
     ```bash
     git checkout -b feature/your-feature-name



  提供版本資訊與開放授權說明。
  ```markdown


  目前版本：1.0.0



  此專案採用 MIT License 授權。詳情請參閱 [LICENSE](./LICENSE) 檔案。


pkgId: 15452e297f55b92fc069639a2bf4b89133cb5a2d655285d8b9db246174549a01
name: python-matrice-help
arch: noarch
version: 1.0.98231
epoch: 0
release: 1
summary: Development documents and examples for matrice
url: https://github.com/matrice-ai/python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-matrice-1.0.98231-1.src.rpm
location_href: Packages/python-matrice-help-1.0.98231-1.noarch.rpm
checksum_type: sha256
description:
  The matrice-datasets-sdk is a python package that has APIs defined in it to perform operations related to datasets on the matrice.ai platform.



  ```
  git clone https://github.com/matrice-ai/matrice-dataset-sdk.git
  cd matrice-database-sdk
  ```


  ```
  python_sdk/
  ├── docs/
  │   ├── Be-Annotation.md
  │   ├── Be-Dataset.md
  │   ├── Be-Deployment.md
  │   ├── Be-Model.md
  │   ├── Be-Project.md
  │   ├── Be-Resources.py
  │   ├── Be-User.py
  │   └── Inference-Optimization.md
  ├── src/
  │   ├── annotation.py
  │   ├── dataset.py
  │   ├── deployment.py
  │   ├── inference_optim.py
  │   ├── models.py
  │   ├── resources.py
  │   ├── rpc.py
  │   └── token_auth.py
  ├── test/
  │   ├── annotation.ipynb
  │   ├── config.py
  │   ├── dataset.ipynb
  │   ├── deployment.ipynb
  │   ├── inference_optim.ipynb
  │   ├── projects.ipynb
  │   ├── models.ipynb
  │   ├── resources.ipynb
  │   └── user.ipynb
  ├── setup.py
  └── README.md
  ```





  All the operations on a dataset will be performed via the methods of the `Dataset` class. So, before performing any operation on the datasets, we need to instantiate an object of the `Dataset` class.

  ```python
  class dataset.Dataset(project_id, dataset_id=None, email="", password="")
  ```

  This constructor should be used to instantiate an object of the `Dataset` class.
  Parameters in the constructor:

  * `project_id`: string, the id of the project in which you want to create the dataset
  * `dataset_id`: string, the id of the dataset on which you want to perform operations
  * `email`:  string, email associated with the matrice.ai platform account
  * `password`: string, password for your account corresponding to `email` for the matrice.ai platform

  If you want to create a new dataset and perform some operations on it, you can instantiate an object of the `Dataset` class without setting the value of `dataset_id`.

  ```python3


  from src.dataset import Dataset


  my_email = "example@gmail.com"


  my_password = "password"


  project_id = "abcc123facc"


  d1 = Dataset(project_id = project_id,email=email, password=password)

  ```

  If you want to perform any operation on an already created dataset, you will have to set the value of `dataset_id` to the id of the dataset on which you want to perform operations while instantiating the object of the `Datasets` class.

  ```python3


  my_email = "example@gmail.com"


  my_password = "password"


  project_id = "abcc123facc"


  dataset_id = "addfc123facc"


  d1 = Dataset(project_id = project_id, dataset_id = dataset_id ,email=email, password=password)

  ```

  Note:
  All the methods defined in `Dataset` will return `response`, `error`, and `message`. The `response` will be the response given by the `matrice.ai` backend, `error` will represent the error message(if there is any error else `None`) and `message` will be a simple text message that provides information about the status of the task being requested to execute.



  To create a dataset in the matrice.ai platform using the `matrice-datasets-sdk`, we can use the `create_dataset()` method defined in the `dataset.Dataset` class. Before, calling the `create_dataset` method, we instantiate an object of the `Dataset` class.

  ```
  dataset.Dataset.create_dataset(self, name, type, is_unlabeled, source, source_url, dataset_description="", version_description="")
  ```

  Parameters in the method:

  * `name`: string, name of the dataset to be created
  * `type`: string, type of the task of the dataset (for now we support `"classification"` and `"detection"` types)
  * `is_unlabeled`:  boolean (True/False), True if the dataset is unlabeled
  * `source`: string, Source for dataset files (currently supported only "url")
  * `source_url` : string, URL of the dataset zipped file
  * `dataset_description`: string, Optional field that is used to store some information about the dataset we are creating
  * `version_description`: string, Optional field that is used to store some information about the `v1.0` of the dataset


  In the matrice.ai platform, we can create a new dataset either by uploading local `zip` files or by using a URL of the dataset files stored somewhere remotely.

  To create a dataset using the URL of the dataset files, we pass source="url" and pass URL of files as the `source_url` argument.

  ```python3
  resp, err, msg = d1.create_dataset(name = "dataset-name",type="detection", is_unlabeled=False, source="url", source_url="https://example.com/sample2_data.tar.gz", dataset_description="Dataset created using matricesdk", version_description="Initial Version")
  ```



  To add new samples to the existing dataset, we can use the `add_new_samples()` method defined in the `dataset.Dataset` class.

  ```
  dataset.Dataset.add_new_samples(self,old_version, new_version, is_unlabeled, source, source_url, dataset_description="", version_description="")
  ```

  Parameters in the method:

  * `old_version`: string, the version of the dataset to which you want to add samples
  * `new_version`: string, the new version of the dataset with added samples (set new_version equal to old_version argument if you don't want to create a new version)
  * `is_unlabeled`:  boolean (True/False), True if the dataset is unlabeled
  * `source`: string, Source for dataset files (currently supported only "url")
  * `source_url`: string, URL of the dataset zipped file
  * `dataset_description`: string, Optional field if set to a string updates existing description of the dataset
  * `version_description`: string, Optional field. Used to set the description of a version if we are creating a new version or used to update the description of a version if we are updating an existing version


  In the matrice.ai platform, we can add new samples to the existing dataset either by uploading local `zip` files or by using a URL of the dataset files stored somewhere remotely.

  To add new samples to the existing dataset using the URL of the dataset files, we pass source="url" and pass URL of files as the `source_url` argument.

  ```python3
  resp, err, msg = d1.add_new_samples(old_version="v1.0", new_version="v1.0", is_unlabeled=False, source="url", source_url="https://myexample.com/sample2_data.tar.gz")
  ```

  The python statement above will add new samples to version `v1.0` of the `d1` dataset using the files in the `source_url`. It will not create a new version in this case.

  ```python3
  resp, err, msg = d1.add_new_samples(old_version="v1.0", new_version="v1.1", is_unlabeled=False, source="url", source_url="https://s3.us-west-2.amazonaws.com/temp.matrice/sample2_data.tar.gz",version_description="Adding samples")
  ```

  The python statement above will add new samples to version `v1.0` of the `d1` dataset using the files in the `source_url and store the final result as version `v1.1`.



  To move samples from one split to another split or create new random splits in the existing dataset, one can use the `split_dataset()` method defined in the `dataset.Dataset` class.

  ```
  dataset.Dataset.split_dataset(self,old_version, new_version, is_random_split, train_num=0, val_num=0, test_num=0, unassigned_num=0.dataset_description="", version_description="",)
  ```

  Parameters in the method:

  * `old_version`: string, the version of the dataset in which you want to move samples from one split to another split or create new random splits
  * `new_version`: string, the new version of the dataset with added samples (set new_version equal to old_version argument if you don't want to create a new version)
  * `is_random_split`:  boolean (True/False), set to True if you want to create fresh new random splits
  * `train_num`: int, Number of samples you want to be in the training set
  * `val_num`: int, Number of samples you want to be in the validation set
  * `test_num`: int, Number of samples you want to be in the test set
  * `unassigned_num`: int, Number of samples you want to be in the unassigned set
  * `dataset_description`: string, Optional field if set to a string updates existing description of the dataset
  * `version_description`: string, Optional field. Used to set the description of a version if we are creating a new version or used to update the description of a version if we are updating an existing version



  To delete a specific version of a dataset, we can use the `delete_version()` method defined in the `dataset.Dataset` class.

  ```
  delete_version(self, version):
  ```

  Parameters in the method:

  * `version`: string, version of the dataset to be deleted

  ```python3
  resp, err, msg = d1.delete_version("v1.2")
  ```

  The Python statement above will delete version `v1.2` of the `d1` dataset.




  To delete a dataset, we can use the `delete_dataset()` method defined in the `dataset.Dataset` class.

  ```
  delete_dataset(self)
  ```

  ```python3
  resp, err, msg = d1.delete_dataset()
  ```

  The Python statement above will delete the `d1` dataset.




  To rename a dataset, one can use the `rename_dataset()` method defined in the `dataset.Dataset` class.

  ```
  rename_dataset(self, updated_name)
  ```

  Parameters in the method:

  * `updated_name`: string, the name you want the dataset to rename to

  ```python3
  resp, err, message = d1.rename_dataset(updated_name="my_dataset")
  ```

  The Python statement above will rename the `d1` dataset to `my_dataset`.




  To get a list of all the datasets inside a project, one can use the `get_all_datasets()` method defined in the `dataset.Dataset` class.

  ```
  get_all_datasets(self)
  ```

  ```python3
  resp, err, message = d1.get_all_datasets()
  ```

  The Python statement above will list all the datasets inside the `project_id` of `d1`.




  To get information about a particular dataset inside a project, we can use the `get_dataset_info()` method defined in the `dataset.Dataset` class.

  ```
  get_dataset_info(self)
  ```

  ```python3
  resp, err, message = d1.get_dataset_info()
  ```

  The Python statement above will provide us with the information about `d1`.




  To get a summary of a particular version of a dataset, one can use the `get_version_summary()` method defined in the `dataset.Dataset` class.

  ```
  get_version_summary(self, version)
  ```

  Parameters in the method:

  * `version`: string, version of the dataset whose summary you want to get

  ```python3
  resp, err, msg = d1.get_version_summary("v1.0")
  ```

  The Python statement above will provide us with the summary of version `v1.0` of dataset `d1`.




  To list all the versions of a dataset, one can use the `list_versions()` method defined in the `dataset.Dataset` class.

  ```
  list_versions(self)
  ```

  ```python3
  resp, err, msg = d1.list_versions()
  ```

  The Python statement above will provide us with the latest version and the list of all versions of the dataset `d1`.




  To list all the label categories of a dataset, one can use the `list_categories()` method defined in the `dataset.Dataset` class.

  ```
  list_categories(self)
  ```

  ```python3
  resp, err, msg = d1.list_categories()
  ```

  The Python statement above will provide us with all the label categories of the dataset `d1`.




  To list all the logs for a dataset, one can use the `get_logs()` method defined in the `dataset.Dataset` class.

  ```
  get_logs(self)
  ```

  ```python3
  resp, err, msg = d1.get_logs()
  ```

  The Python statement above will give us a list of all the logs for the dataset `d1`.




  To list all the dataset items in a dataset, one can use the `list_all_dataset_items()` method defined in the `dataset.Dataset` class.

  ```
  list_all_dataset_items(self, version)
  ```

  Parameters in the method:

  * `version`: string, version of the dataset whose items you want to get

  ```python3
  resp, err, msg = d1.list_all_dataset_items(version="v1.0")
  ```

  The Python statement above will give us a list of all the dataset items in version `v1.0` of the dataset `d1`.


pkgId: cca488e889b367740aa9b8a8a1f98ca55df40634aff882cddb57cf73850e3043
name: python-matrix-disk-cache-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for matrix-disk-cache
url: https://github.com/modyf01/Disk-Cache
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-matrix-disk-cache-0.1.3-1.src.rpm
location_href: Packages/python-matrix-disk-cache-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  You can install MatrixDiskCache via pip (soon to be available on PyPI):
  ```bash
  pip install matrix-disk-cache


pkgId: 2c2c84929021e036b1bc28290c424b2c4aa5bd21be2d47c3316e9150664a5407
name: python-mausy5043-common-help
arch: noarch
version: 1.10.1
epoch: 0
release: 1
summary: Development documents and examples for mausy5043-common
url: https://github.com/Mausy5043/mausy5043-common
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mausy5043-common-1.10.1-1.src.rpm
location_href: Packages/python-mausy5043-common-help-1.10.1-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/mausy5043/mausy5043-common)](LICENSE)
  [![PyPI version](https://img.shields.io/pypi/v/mausy5043-common.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/mausy5043-common)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/mausy5043-common.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/mausy5043-common)
  [![PyPI downloads](https://img.shields.io/pypi/dm/mausy5043-common.svg)](https://pypistats.org/packages/mausy5043-common)
  [![Code style: Black](https://img.shields.io/badge/code%20style-Black-000000.svg)](https://github.com/psf/black)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Mausy5043/mausy5043-common/devel.svg)](https://results.pre-commit.ci/latest/github/Mausy5043/mausy5043-common/devel)



  This is a Python3 library of functions and classes, mainly for personal use.



  **NOTE: user action required !!**
  Before trying to use the SQLITE3 functions in this package make sure you have installed the sqlite3 server/client and
  the default Python package that comes with it.

  Development of this package is done in Python 3.12. Backwards compatibility is not tested; if it works on Python 3.7 or before consider yourself lucky. [Python versions that are end-of-life](https://devguide.python.org/versions/) are not supported.



  ```
  python3 -m pip install mausy5043-common
  ```



  `cat(filename)` : Read a file into a variable.
  `syslog_trace(trace, logerr, out2console)` : Log messages to console and/or system log.
  `moisture(temperature, relative_humidity, pressure)` : Calculate the moisture content of air given T [degC], RH [%] and P [hPa].
  `wet_bulb_temperature(temperature, relative_humidity)` : Calculate the wet bulb temperature of the air given T [degC] and RH [%].


  `SqlDatabase` : A class to interact with SQLite3 databases.


  As of September 2024 `mausy5043-common` is distributed under [AGPL-3.0-or-later](LICENSE).


pkgId: 976909ce90399b3b174431692d05a9f569d87b81d9fcd0729cc68bd8dc5ea019
name: python-max-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for max
url: https://pypi.org/project/max/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-max-0.0.1-1.src.rpm
location_href: Packages/python-max-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Notice: This package is temporary placeholder for future releases of the Modular
  MAX SDK on PyPI. Today MAX is currently avalaible as a conda package.

  Learn more about MAX at: <https://www.modular.com/max>



  ![Modular GitHub Logo](https://modular-assets.s3.amazonaws.com/images/modular_github_logo_bg.png)

  The Modular Accelerated Xecution ([MAX](https://www.modular.com/max)) platform
  is an integrated suite of AI libraries, tools, and technologies that unifies
  commonly fragmented AI deployment workflows. MAX accelerates time to market
  for the latest innovations by giving AI developers a single toolchain that
  unlocks full programmability, unparalleled performance, and seamless hardware portability.

  ![Modular Architecture Diagram](https://modular-assets.s3.amazonaws.com/images/modular_architecture_diagram_bg.png)

  [See here to get started with MAX](https://docs.modular.com/max/get-started)
  and when you want to report issues or request features,
  [please create a GitHub issue here](https://github.com/modularml/max/issues/new/choose).

  The [Discord](https://discord.gg/modular) community is the best place to share
  your experiences and chat with the team and other community members.


pkgId: 9e771e2aa105ed6d49fbcd2c92d307cad75753b84bd28bf485569954b375383f
name: python-maxrf4u-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for maxrf4u
url: https://github.com/fligt/maxrf4u
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-maxrf4u-0.1.8-1.src.rpm
location_href: Packages/python-maxrf4u-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  Macro X-Ray Fluorescence (MA-XRF) scanning of cultural heritage objects
  is becoming a standard technique that is increasingly applied also to
  paper based artworks. Unfortunately, the visualization and
  interpretation of MA-XRF data is technically challenging and therefore
  obstructing interdisciplinary cooperation. That is why I have started to
  develop the open source python package `maxrf4u` to help you and me with
  our data analysis.

  This package is developed out in the open. If you are interested you can
  follow my ideas under construction in this documentation and already try
  out the Jupyter
  [notebooks](https://github.com/fligt/maxrf4u/tree/main/notebooks) in
  this repository. My goal is to make the package available for
  installation soon…

  Frank Ligterink

  See [link](https://fligt.github.io/maxrf4u/) to documentation.


pkgId: c93f9d5b3980349a05b6b652e4fecf65f2e102a7bd2be4655ec5fc70ed3cda1e
name: python-mbapy-help
arch: noarch
version: 0.10.3
epoch: 0
release: 1
summary: Development documents and examples for mbapy
url: https://github.com/BHM-Bob/BA_PY
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mbapy-0.10.3-1.src.rpm
location_href: Packages/python-mbapy-help-0.10.3-1.noarch.rpm
checksum_type: sha256
description:
  <!--
   * @Author: BHM-Bob 2262029386@qq.com
   * @Date: 2022-10-19 22:16:22
   * @LastEditors: BHM-Bob 2262029386@qq.com
   * @LastEditTime: 2024-10-19 16:38:17
   * @Description:
  -->

  <h1 style="text-align:center;">BA_PY: Optimize Your Workflow with Python!</h1>

  <p style="text-align:center;">
  <a href="https://www.pepy.tech/projects/mbapy"><img src="https://static.pepy.tech/badge/mbapy" alt="Downloads" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <img src="https://img.shields.io/pypi/dm/mbapy" alt="Downloads" style="display:inline-block; margin-left:auto; margin-right:auto;" />
  <img src="https://img.shields.io/github/downloads/BHM-Bob/BA_PY/total?label=GitHub%20all%20releases%20downloads" alt="Downloads" style="display:inline-block; margin-left:auto; margin-right:auto;" />
  </p>

  <p style="text-align:center;">
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://img.shields.io/github/repo-size/BHM-Bob/BA_PY" alt="repo size" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://img.shields.io/github/languages/code-size/BHM-Bob/BA_PY" alt="code size" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://github.com/BHM-Bob/BA_PY/releases"><img src="https://img.shields.io/github/v/release/BHM-Bob/BA_PY?label=GitHub%20Release" alt="GitHub release (latest by date)" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://github.com/BHM-Bob/BA_PY/releases"><img src="https://img.shields.io/github/commit-activity/m/BHM-Bob/BA_PY" alt="GitHub Commit Activity" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a><img src="https://img.shields.io/github/last-commit/BHM-Bob/BA_PY?label=GitHub%20Last%20Commit" alt="GitHub last commit" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  </p>

  <p style="text-align:center;">
  <a href="https://pypi.org/project/mbapy/"><img src="https://img.shields.io/pypi/status/mbapy?label=PyPI%20Status" alt="PyPI Status" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://pypi.org/project/mbapy/"><img src="https://img.shields.io/pypi/v/mbapy?label=PyPI%20Release" alt="PyPI" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://pypi.org/project/mbapy/"><img src="https://img.shields.io/pypi/pyversions/mbapy" alt="python versions" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  </p>

  <p style="text-align:center;">
  <img alt="GitHub language count" src="https://img.shields.io/github/languages/count/BHM-Bob/BA_PY">
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://img.shields.io/readthedocs/ba-py" alt="docs" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://img.shields.io/github/license/BHM-Bob/BA_PY" alt="license" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://codeium.com/badges/main" alt="codeium" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  </p>

  <p style="text-align:center;">
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://camo.githubusercontent.com/c292429e232884db22e86c2ea2ea7695bc49dc4ae13344003a95879eeb7425d8/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f57696e646f77732d3030373844363f7374796c653d666f722d7468652d6261646765266c6f676f3d77696e646f7773266c6f676f436f6c6f723d7768697465" alt="windows" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  <a href="https://github.com/BHM-Bob/BA_PY/"><img src="https://camo.githubusercontent.com/7eefb2ba052806d8a9ce69863c2eeb3b03cd5935ead7bd2e9245ae2e705a1adf/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c696e75782d4643433632343f7374796c653d666f722d7468652d6261646765266c6f676f3d6c696e7578266c6f676f436f6c6f723d626c61636b" alt="linux" style="display:inline-block; margin-left:auto; margin-right:auto;" /></a>
  </p>


  mbapy is a Python package that includes a collection of useful Python scripts as sub-modules, and it's goal is *Basic for All in Python*.
  mbapy primarily focus on data works, including data-retrieval, data-management, data-visualization, data-analysis and data-computation. It is built for both python-users and command-line-users.

  <h2 style="text-align:center;">Get start</h2>


  Now, mbapy only support pypi install:
  ```
  pip install mbapy
  ```

  mbapy is a multi-funtional package, and it does not require every third-party packages to make every sub-module work. However, it provides some requriements option to install more specified requirements to make some sub-modules work:
  1. bio: some packages for biology(sci).
      install as `pip install mbapy[bio]`
  2. game: some packages for game(pygame).
      install as `pip install mbapy[game]`
  3. full: full requirements to make almost every sub-module in mbapy work(except dl_torch).
       install as `pip install mbapy[full]`

  If you find the latest release version has some problems, you can try install the up-to-date version on github or gitee:
  ```
  pip install git+https://github.com/BHM-Bob/BA_PY.git
  ```
  ```
  pip install git+https://gitee.com/BHM-Bob/BA_PY.git
  ```


  The documentation for mbapy can be found on [read the docs](https://ba-py.readthedocs.io/en/latest/) or just in the `docs` folder.


  - open source at:
      1. [github： https://github.com/BHM-Bob/BA_PY](https://github.com/BHM-Bob/BA_PY)
      2. [gitee： https://gitee.com/BHM-Bob/BA_PY](https://gitee.com/BHM-Bob/BA_PY)
      3. [SourceForge： https://sourceforge.net/projects/ba-py/](https://sourceforge.net/projects/ba-py/)
  - docs at: [read the docs: https://ba-py.rtfd.io](https://ba-py.readthedocs.io/en/latest/)
  - PyPI: [https://pypi.org/project/mbapy/](https://pypi.org/project/mbapy/)

  <h2 style="text-align:center;">Contents</h2>



  *some version info*


  *some utils for easier coding*



  *imgae utils*, including reading, saving and process a image into a feature tensor via pytorch.

  *video utils*, including extract frames or unique frames from a video.


  *pandas.dataFrame utils for plot and some simple plot based on plt*


  *utils for web-crawler*

  *get a web hyml page or a selenium browser warpper for easier usage*.

  *utils for parsing html*

  *small task manager*

  *a light-weight web spider architecture*



  *BAKmeans, KOptim, KBayesian from KMeans, and a func for many cluster*

  *pandas.dataFrame utils for stats*

  *regression*

  *some test func(using scipy and mostly give a support for mbapy-style data input)*


  *pytorch utils for deeplearning*

  *basic blocks : tiny network structures*

  *utils for dataset loading*

  *some loss function*

  *model : deeplearning model constructed with basic blocks*

  *deeplearning training utils*

  *learning rate scheduler*


  *sci-paper utils, contains paper searching, downloading and parsing*

  *search papers via pubmed, baidu xueshu, wos*

  *download papers via scihub*

  *parse paper from a pdf file into a dict of each sections*



  *class and funcs to calcu peptide MW, mutations*

  *some high-level utils for bio*



  *HPLC instrument data processing and visualization*

  *mass spectrometry instrument data processing and visualization*


  *some useful scripts for command user*
  launch by `python -m mbapy.scripts.XXX` or `mbapy-cli XXX`.



  1. chaoxin ppt multi threads downloader (jpg->pdf)
  2. wujin search http://www.basechem.org
  3. chemSub search http://chemsub.online.fr
  4. cnipa https://pss-system.cponline.cnipa.gov.cn/seniorSearch



  1. mbapy requires python 3.8~3.11 because of the use of type hint and require matplotlib>=3.7.5, and the developer do not test it on other python version.
  2. mbapy only requires a part of third-party packages in a specific version. This is because the developer do not want to make a big change during the installation. Bellow are the specific requirements:
  - `matplotlib>=3.7.5`: HPLC and Mass data visualization need set legend `draggable`, this is only supported in 3.7+
  - `seaborn>=0.13.0`: plot_utils.bar_utils.plot_bar need set seaborn stripplot `native_scale`, this is only supported in 0.13+
  - `nicegui[highcharts]`: scripts/hplc: explore-hplc need a highcharts as interactive plot for manual peaking.
  - `torch any`: though dl_torch is important for mbapy, but the developer kowns torch is a big package, and do not has a specific function requirement.


pkgId: 717e6459f47ab570012a382719c0b307005963520afaa502a36a910896db3cd5
name: python-mbrs-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for mbrs
url: https://pypi.org/project/mbrs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mbrs-0.1.4-1.src.rpm
location_href: Packages/python-mbrs-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="https://raw.githubusercontent.com/naist-nlp/mbrs/main/docs/icon.svg" height="240px">
  </p>

  <p align="center">
  <i>mbrs</i> is a library for minimum Bayes risk (MBR) decoding.
  </p>

  <p align="center">
  <a href="https://pypi.org/project/mbrs"><img alt="PyPi" src="https://img.shields.io/pypi/v/mbrs"></a>
  <a href="https://github.com/naist-nlp/mbrs/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/naist-nlp/mbrs.svg"></a>
  <a href=""><img src="https://github.com/naist-nlp/mbrs/actions/workflows/ci.yaml/badge.svg"></a>
  </p>
  <p align="center">
  <b>
        <a href="https://aclanthology.org/2024.emnlp-demo.37">Paper</a> |
        <a href="https://mbrs.readthedocs.io">Reference docs</a> |
        <a href="https://github.com/naist-nlp/mbrs#citation">Citation</a> |
        <a href="https://github.com/naist-nlp/mbrs/releases">Release notes</a>
  </b>
  </p>



  You can install from PyPi:

  ``` bash
  pip install mbrs
  ```

  For developers, it can be installed from the source.

  ``` bash
  git clone https://github.com/naist-nlp/mbrs.git
  cd mbrs/
  pip install ./
  ```

  For uv users:
  ``` bash
  git clone https://github.com/naist-nlp/mbrs.git
  cd mbrs/
  uv sync
  ```



  mbrs provides two interfaces: command-line interface (CLI) and Python
  API.



  Command-line interface can run MBR decoding from command-line. Before
  running MBR decoding, you can generate hypothesis sentences with
  `mbrs-generate`:

  ``` bash
  mbrs-generate \
    sources.txt \
    --output hypotheses.txt \
    --lang_pair en-de \
    --model facebook/m2m100_418M \
    --num_candidates 1024 \
    --sampling eps --epsilon 0.02 \
    --batch_size 8 --sampling_size 8 --fp16 \
    --report_format rounded_outline
  ```

  Beam search can also be used by replacing
  `--sampling eps --epsilon 0.02` with `--beam_size 10`.

  Next, MBR decoding and other decoding methods can be executed with
  `mbrs-decode`. This example regards the hypothesis set as the
  pseudo-reference set.

  ``` bash
  mbrs-decode \
    hypotheses.txt \
    --num_candidates 1024 \
    --nbest 1 \
    --source sources.txt \
    --references hypotheses.txt \
    --output translations.txt \
    --report report.txt --report_format rounded_outline \
    --decoder mbr \
    --metric comet \
    --metric.model Unbabel/wmt22-comet-da \
    --metric.batch_size 64 --metric.fp16 true
  ```

  You can pass the arguments using a configuration yaml file via
  `--config_path` option. See
  [docs](https://mbrs.readthedocs.io/en/latest/yaml_config.html) for the
  details.

  Finally, you can evaluate the score with `mbrs-score`:

  ``` bash
  mbrs-score \
    hypotheses.txt \
    --sources sources.txt \
    --references hypotheses.txt \
    --format json \
    --metric bleurt \
    --metric.batch_size 64 --metric.fp16 true
  ```



  This is the example of COMET-MBR via Python API.

  ``` python
  from mbrs.metrics import MetricCOMET
  from mbrs.decoders import DecoderMBR

  SOURCE = "ありがとう"
  HYPOTHESES = ["Thanks", "Thank you", "Thank you so much", "Thank you.", "thank you"]


  metric_cfg = MetricCOMET.Config(
    model="Unbabel/wmt22-comet-da",
    batch_size=64,
    fp16=True,
  )
  metric = MetricCOMET(metric_cfg)


  decoder_cfg = DecoderMBR.Config()
  decoder = DecoderMBR(decoder_cfg, metric)




  output = decoder.decode(HYPOTHESES, HYPOTHESES, source=SOURCE, nbest=1)

  print(f"Selected index: {output.idx}")
  print(f"Output sentence: {output.sentence}")
  print(f"Expected score: {output.score}")
  ```





  Currently, the following metrics are supported:

  -   BLEU [(Papineni et al., 2002)](https://aclanthology.org/P02-1040):
      `bleu`
  -   TER [(Snover et al.,
      2006)](https://aclanthology.org/2006.amta-papers.25): `ter`
  -   chrF [(Popović et al., 2015)](https://aclanthology.org/W15-3049):
      `chrf`
  -   COMET [(Rei et al.,
      2020)](https://aclanthology.org/2020.emnlp-main.213): `comet`
  -   COMETkiwi [(Rei et al.,
      2022)](https://aclanthology.org/2022.wmt-1.60): `cometkiwi`
  -   XCOMET [(Guerreiro et al., 2023)](https://doi.org/10.1162/tacl_a_00683):
      `xcomet`
  -   XCOMET-lite [(Larionov et al., 2024)](https://aclanthology.org/2024.emnlp-main.1223):
      `xcomet` with `--metric.model="myyycroft/XCOMET-lite"`
  -   BLEURT [(Sellam et al.,
      2020)](https://aclanthology.org/2020.acl-main.704): `bleurt` (thanks
      to [\@lucadiliello](https://github.com/lucadiliello/bleurt-pytorch))
  -   MetricX ([Juraska et al., 2023](https://aclanthology.org/2023.wmt-1.63);
      [Juraska et al., 2024](https://aclanthology.org/2024.wmt-1.35)): `metricx`
  -   BERTScore [(Zhang et al., 2020)](https://openreview.net/forum?id=SkeHuCVFDr): `bertscore`



  The following decoding methods are implemented:

  -   N-best reranking: `rerank`
  -   MBR decoding: `mbr`

  Specifically, the following methods of MBR decoding are included:

  -   Expectation estimation:
      -   Monte Carlo estimation ([Eikema and Aziz,
          2020](https://aclanthology.org/2020.coling-main.398); [Eikema
          and Aziz, 2022](https://aclanthology.org/2022.emnlp-main.754))
      -   Model-based estimation [(Jinnai et al.,
          2024)](https://proceedings.mlr.press/v235/jinnai24a.html): `--reference_lprobs`
          option
  -   Efficient methods:
      -   Confidence-based pruning [(Cheng and Vlachos,
          2023)](https://aclanthology.org/2023.emnlp-main.767) :
          `pruning_mbr`
      -   Reference aggregation ([DeNero et al.,
          2009](https://aclanthology.org/P09-1064); [Vamvas and Sennrich,
          2024](https://aclanthology.org/2024.acl-short.71)): `aggregate_mbr`
          -   N-gram aggregation on BLEU [(DeNero et al.,
              2009)](https://aclanthology.org/P09-1064)
          -   N-gram aggregation on chrF [(Vamvas and Sennrich,
              2024)](https://aclanthology.org/2024.acl-short.71)
          -   Embedding aggregation on COMET ([Vamvas and Sennrich,
              2024](https://aclanthology.org/2024.acl-short.71); [Deguchi et al.,
              2024](https://aclanthology.org/2024.findings-acl.654))
      -   Centroid-based MBR [(Deguchi et al.,
          2024)](https://aclanthology.org/2024.findings-acl.654): `centroid_mbr`
      -   Probabilistic MBR [(Trabelsi et al.,
          2024)](https://arxiv.org/abs/2406.02832): `probabilistic_mbr`



  The final output list is selected according to these selectors:

  -   N-best selection: `nbest`
  -   Diverse selection [(Jinnai et al., 2024)](https://aclanthology.org/2024.findings-acl.503): `diverse`



  -   [mbr](https://github.com/ZurichNLP/mbr)
      -   Highly integrated with [huggingface
          transformers](https://huggingface.co/transformers) by
          customizing `generate()` method of model
          implementation.
      -   If you are looking for an MBR decoding library that is fully
          integrated into transformers, this might be a good choice.
      -   Our mbrs works standalone; thus, not only
          [transformers](https://huggingface.co/transformers) but also
          [fairseq](https://github.com/facebookresearch/fairseq) or LLM
          outputs via API can be used.



  If you use this software, please cite:

  ``` bibtex
  @inproceedings{deguchi-etal-2024-mbrs,
      title = "mbrs: A Library for Minimum {B}ayes Risk Decoding",
      author = "Deguchi, Hiroyuki  and
        Sakai, Yusuke  and
        Kamigaito, Hidetaka  and
        Watanabe, Taro",
      editor = "Hernandez Farias, Delia Irazu  and
        Hope, Tom  and
        Li, Manling",
      booktitle = "Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
      month = nov,
      year = "2024",
      address = "Miami, Florida, USA",
      publisher = "Association for Computational Linguistics",
      url = "https://aclanthology.org/2024.emnlp-demo.37",
      pages = "351--362",
  }
  ```



  This library is mainly developed by [Hiroyuki
  Deguchi](https://sites.google.com/view/hdeguchi) and published under the
  MIT-license.


pkgId: 5783aa5974e4964cb307792ba06ebad0e50f6374f9bdf783ddc709d0c60f822e
name: python-mbtrack2-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for mbtrack2
url: https://gitlab.synchrotron-soleil.fr/PA/collective-effects/mbtrack2
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mbtrack2-0.8.0-1.src.rpm
location_href: Packages/python-mbtrack2-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  [![GitLab Release](https://img.shields.io/gitlab/v/release/184?gitlab_url=https%3A%2F%2Fgitlab.synchrotron-soleil.fr%2F)](https://gitlab.synchrotron-soleil.fr/PA/collective-effects/mbtrack2/-/releases) [![PyPI - Version](https://img.shields.io/pypi/v/mbtrack2)](https://pypi.org/project/mbtrack2/)
  [![PyPI - License](https://img.shields.io/pypi/l/mbtrack2)](https://gitlab.synchrotron-soleil.fr/PA/collective-effects/mbtrack2/-/blob/stable/LICENSE)
  [![Read the Docs](https://img.shields.io/readthedocs/mbtrack2)](https://mbtrack2.readthedocs.io/)
  mbtrack2 is a coherent object-oriented framework written in python to work on collective effects in synchrotrons.
  mbtrack2 is composed of different modules allowing to easily write scripts for single bunch or multi-bunch tracking using MPI parallelization in a transparent way. The base of the tracking model of mbtrack2 is inspired by mbtrack, a C multi-bunch tracking code initially developed at SOLEIL.


pkgId: 9a49e5092e3f9fa8e86a9d85f778a8b18c82fd2cec41ca4ea2af9872436d1462
name: python-mcc-api-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for mcc-api
url: https://pypi.org/project/mcc-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcc-api-1.2.0-1.src.rpm
location_href: Packages/python-mcc-api-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![🐍 PyPI](https://img.shields.io/pypi/v/mcc-api?label=🐍%20PyPI)](https://pypi.org/project/mcc-api/)
  [![👑 Targeting Event API v1.6.0](https://img.shields.io/badge/👑_Targeting_Event_API-v1.6.0-red)](https://github.com/Noxcrew/mcchampionship-api/releases/tag/v1.6.0)
  [![🏝️ Targeting Island API v24.12.17](https://img.shields.io/badge/🏝️_Targeting_Island_API-v24.12.17-aqua)](https://github.com/Noxcrew/mccisland-api/releases/tag/v24.12.17)

  A helper library for the [MC Championship](https://mcchampionship.com) APIs
  ([Event](https://github.com/Noxcrew/mcchampionship-api), inspired by [derNiklaas's](https://github.com/derNiklaas)
  [node-mcc-api](https://github.com/derNiklaas/node-mcc-api) project, and
  [Island](https://github.com/Noxcrew/mccisland-api)).

  - Issues: [https://github.com/JamesMCo/python_mcc_api/issues](https://github.com/JamesMCo/python_mcc_api/issues)
  - MCC Event API documentation: [https://api.mcchampionship.com/docs](https://api.mcchampionship.com/docs)
  - MCC Island API documentation: [https://api.mccisland.net/docs](https://api.mccisland.net/docs)
  - Module documentation: [https://mrjamesco.uk/python_mcc_api](https://mrjamesco.uk/python_mcc_api)
  - PyPI: [https://pypi.org/project/mcc-api/](https://pypi.org/project/mcc-api/)
  - Repository: [https://github.com/JamesMCo/python_mcc_api](https://github.com/JamesMCo/python_mcc_api)



  Ensure that [pip](https://packaging.python.org/en/latest/key_projects/#pip) is updated using:

  ```bash
  python -m pip install --upgrade pip
  ```

  Then install or update `mcc_api` using:

  ```bash
  pip install --upgrade mcc-api
  ```





  The event library provides methods to call each of the endpoints described in the MC Championship Event API's
  [documentation](https://api.mcchampionship.com/docs).

  ```python
  from datetime import datetime, timezone
  from mcc_api.event import get_event, get_rundown



  event = get_event()
  event_name = event.data.event
  event_start = event.data.date.strftime("%I%p UTC on %A %d %B %Y")

  if event.data.date <= datetime.now(tz=timezone.utc):
      print(f"The latest event (MCC {event_name}) started at {event_start}.")
  else:
      print(f"The upcoming event (MCC {event_name}) starts at {event_start}.")




  rundown = get_rundown()

  dodgebolt_teams = rundown.data.dodgeboltData.keys()
  players = sorted([player for team in dodgebolt_teams for player in rundown.data.creators[team]], key=str.casefold)

  print(f"The players that played in Dodgebolt in the latest event were:\n- {'\n- '.join(players)}")
  ```



  The island library provides an implementation of the GraphQL schema described in the MCC Island API's
  [documentation](https://api.mccisland.net/docs). Queries are written in GraphQL, and validated locally before being sent
  to the API.

  Accessing the MCC Island API requires an API key, which can be minted using
  [Noxcrew Gateway](https://gateway.noxcrew.com). Then, you can use `mcc_api.island.set_api_key("<YOUR_API_KEY>")` to
  provide authentication for all future requests. It is recommended that you store your API key in an environment
  variable, and don't check it in to your source controlled repository.

  ```python
  from gql import gql
  from mcc_api.island import client, set_api_key

  set_api_key("<YOUR_API_KEY>")


  query = gql("""
      query player($username: String!) {
          playerByUsername(username: $username) {
              username
              status {
                  online
              }
              collections {
                  currency {
                      coins
                  }
              }
              social {
                  friends {
                      uuid
                  }
              }
          }
      }
  """)
  data = client.execute(query, variable_values={"username": "Jammy4312"})

  player = data["playerByUsername"]
  username = player["username"]
  username_s = f"{username}'{'' if player['username'][-1].lower() == 's' else 's'}"

  print(f"Username: {username}")
  if "status" in player:
      print(f"Status:   {'Online' if player['status']['online'] else 'Offline'}")
  else:
      print(f"Status:   Unknown ({username_s} status is private)")

  if "collections" in player:
      print(f"Coins:    {player['collections']['currency']['coins']:,}")
  else:
      print(f"Coins:    Unknown ({username_s} collections are private)")

  if "social" in player:
      print(f"Friends:  {len(player['social']['friends']):,}")
  else:
      print(f"Friends:  Unknown ({username_s} social data are private)")
  ```


pkgId: 8dcba25f2d0fe66906577e37078ba8d20f78da3d1713e8ea0ae23307d8083f34
name: python-mcdreforged-help
arch: noarch
version: 2.13.2
epoch: 0
release: 1
summary: Development documents and examples for mcdreforged
url: https://github.com/MCDReforged/MCDReforged
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcdreforged-2.13.2-1.src.rpm
location_href: Packages/python-mcdreforged-help-2.13.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Python Versions](https://img.shields.io/pypi/pyversions/mcdreforged.svg)](https://pypi.org/project/mcdreforged)
  [![PyPI Version](https://img.shields.io/pypi/v/mcdreforged.svg)](https://pypi.org/project/mcdreforged)
  [![Docker](https://img.shields.io/docker/v/mcdreforged/mcdreforged/latest?label=docker)](https://hub.docker.com/r/mcdreforged/mcdreforged)
  [![License](https://img.shields.io/github/license/MCDReforged/MCDReforged.svg)](https://github.com/MCDReforged/MCDReforged/blob/master/LICENSE)
  [![Documentation Status](https://readthedocs.org/projects/mcdreforged/badge/)](https://docs.mcdreforged.com/)
  ![MCDR-banner](logo_long.png)
  **English** | [中文](https://github.com/MCDReforged/MCDReforged/blob/master/README_cn.md)
  > This is a python based Minecraft server control tool
  MCDReforged (abbreviated as MCDR) is a tool which provides the management ability of the Minecraft server using custom plugin system. It doesn't need to modify or mod the original Minecraft server at all
  From in-game calculator, player high-light, to manipulate scoreboard, manage structure file and backup / load backup, you can implement these by using MCDR and related plugins
  Greatly thanks to chino_desu and his [MCDaemon 1.0](https://github.com/kafuuchino-desu/MCDaemon) for the idea of such a cool Minecraft control tool
  Contact me on discord: `Fallen_Breath#1215`

  - It's running above the server. It doesn't need to modify the server at all which keep everything vanilla
  - Hot-reloadable plugin system. You don't need to shut down the server to update the plugins
  - Multi-platform / server compatibility. Supports vanilla, paper, bungeecord etc. on Linux / Windows

  MCDR uses [Popen](https://docs.python.org/3/library/subprocess.html#subprocess.Popen) to start the server as a sub-process,
  then it has the ability to control the standard input / out stream of the server
  Since the console output of a Minecraft server has a stable format and contains a large amount of useful information about the server,
  e.g. player chat messages, MCDR is able to parse and analyze the server output, abstract them into different events and dispatch them towards plugins for responding
  With the help of Minecraft command system, MCDR can send Minecraft commands via the standard input stream to affect the actual Minecraft server
  That's it, you can even think of MCDR as a robot that stares at the server console and can quickly respond to server output and input related commands if you like

  [Here](https://github.com/MCDReforged/PluginCatalogue) is a MCDR plugin collection repository

  Check https://docs.mcdreforged.com/ for more details of MCDR


pkgId: d59a7de8f5cdeda0e4243f3e26908116a00e49e70bc9b8ba3bde9850a79e25e8
name: python-mcfa-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for mcfa
url: https://github.com/maxmahlke/mcfa.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcfa-0.1.6-1.src.rpm
location_href: Packages/python-mcfa-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![arXiv](https://img.shields.io/badge/arXiv-2203.11229-f9f107.svg)](https://arxiv.org/abs/2203.11229) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  <p align="center">
    <img width="260" src="https://raw.githubusercontent.com/maxmahlke/mcfa/main/gfx/logo_mcfa.png">
  </p>

  This `python` package implements the Mixtures of Common Factor Analyzers model
  introduced by [Baek+ 2010](https://ieeexplore.ieee.org/document/5184847). It
  uses [tensorflow](https://www.tensorflow.org/) to implement a stochastic
  gradient descent, which allows for model training without prior imputation of
  missing data. The interface resembles the [sklearn](https://scikit-learn.org/stable/) model API.



  Refer to the `docs/documentation.ipynb` for the documentation and
  `docs/4d_gaussian.ipynb` for an example application.



  Install from PyPi using `pip`:

       $ pip install mcfa

  The minimum required `python` version is 3.8.



  - [EMMIXmfa](https://github.com/suren-rathnayake/EMMIXmfa) in `R`
  - [Casey+ 2019](https://github.com/andycasey/mcfa) in `python`

  Compared to this implementation, Casey+ 2019 use an EM-algorithm instead of a
  stochastic gradient descent. This requires the imputation of the missing values
  **before** the model training. On the other hand, there are more initialization
  routines the lower space loadings and factors available in the Casey+ 2019 implementation.


pkgId: 2814ed8ddf34ab89db85a37d5efb45fe9473d6af80b4a9e46a3e93baf9ddc889
name: python-mcp-python-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for mcp-python
url: https://hdr.is
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-python-0.1.2-1.src.rpm
location_href: Packages/python-mcp-python-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  This MCP server provides a Python REPL (Read-Eval-Print Loop) as a tool. It allows execution of Python code through the MCP protocol with a persistent session.



  No setup needed! The project uses `uv` for dependency management.



  Simply run:

  ```bash
  uv run src/python_repl/server.py
  ```



  Add this configuration to your Claude Desktop config file:

  ```json
  {
    "mcpServers": {
      "python-repl": {
        "command": "uv",
        "args": [
          "--directory",
          "/absolute/path/to/python-repl-server",
          "run",
          "mcp_python"
        ]
      }
    }
  }
  ```

  The server provides three tools:

  1. `execute_python`: Execute Python code with persistent variables

     - `code`: The Python code to execute
     - `reset`: Optional boolean to reset the session

  2. `list_variables`: Show all variables in the current session

  3. `install_package`: Install a package from pypi



  Set a variable:

  ```python
  a = 42
  ```

  Use the variable:

  ```python
  print(f"The value is {a}")
  ```

  List all variables:

  ```python

  ```

  Reset the session:

  ```python

  ```



  Contributions are welcome! Please feel free to submit a Pull Request. Here are some ways you can contribute:

  - Report bugs
  - Suggest new features
  - Improve documentation
  - Add test cases
  - Submit code improvements

  Before submitting a PR, please ensure:

  1. Your code follows the existing style
  2. You've updated documentation as needed
  3. Maybe write some tests?

  For major changes, please open an issue first to discuss what you would like to change.


pkgId: dc3758a103d8a6419bb823456d9c366433c3d913f072859cc95057d2b3a1284e
name: python-mcp-salesforce-connector-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mcp-salesforce-connector
url: https://github.com/smn2gnt/MCP-Salesforce
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-salesforce-connector-0.1.0-1.src.rpm
location_href: Packages/python-mcp-salesforce-connector-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Model Context Protocol (MCP) server implementation for Salesforce integration, allowing LLMs to interact with Salesforce data through SOQL queries and SOSL searches.



  - Execute SOQL (Salesforce Object Query Language) queries
  - Perform SOSL (Salesforce Object Search Language) searches


pkgId: d7ec4751bc43ec5f7a07d85109f7887bde4f3349df151a00aeda6d50d1fb8ec7
name: python-mcp-salesforce-connector-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for mcp-salesforce-connector
url: https://github.com/smn2gnt/MCP-Salesforce
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-salesforce-connector-0.1.2-1.src.rpm
location_href: Packages/python-mcp-salesforce-connector-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A Model Context Protocol (MCP) server implementation for Salesforce integration, allowing LLMs to interact with Salesforce data through SOQL queries and SOSL searches.



  - Execute SOQL (Salesforce Object Query Language) queries
  - Perform SOSL (Salesforce Object Search Language) searches





  To use this server with the Model Context Protocol, you need to configure it in your `claude_desktop_config.json` file. Add the following entry to the `mcpServers` section:


      {
          "mcpServers": {
              "salesforce": {
              "command": "uvx",
              "args": [
                  "--from",
                  "mcp-salesforce-connector",
                  "salesforce"
              ],
              "env": {
                  "SALESFORCE_USERNAME": "YOUR_SALESFORCE_USERNAME",
                  "SALESFORCE_PASSWORD": "YOUR_SALESFORCE_PASSWORD",
                  "SALESFORCE_SECURITY_TOKEN": "YOUR_SALESFORCE_SECURITY_TOKEN"
                  }
              }
          }
      }

  Replace `YOUR_SALESFORCE_USERNAME`, `YOUR_SALESFORCE_PASSWORD`, and `YOUR_SALESFORCE_SECURITY_TOKEN` with your Salesforce credentials.


pkgId: 21a58a8f35a75ee2bced15fbe4a3b7c27afddc23002d4c6d3376417d5252356b
name: python-mcp-server-everything-search-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mcp-server-everything-search
url: https://pypi.org/project/mcp-server-everything-search/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-server-everything-search-0.1.0-1.src.rpm
location_href: Packages/python-mcp-server-everything-search-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  An MCP server that provides fast file searching capabilities using the Everything SDK.



  1. Windows operating system (required - this server only works on Windows)
  2. [Everything](https://www.voidtools.com/) search utility:
     - Download and install from https://www.voidtools.com/
     - **Make sure the Everything service is running**
  3. Everything SDK:
     - Download from https://www.voidtools.com/support/everything/sdk/
     - Extract the SDK files to a location on your system



  1. Make sure you have Python 3.10+ installed
  2. Clone this repository `git clone https://github.com/mamertofabian/mcp-everything-search.git`
  3. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already
  4. From the project root directory, run:
     ```bash
     uv pip install .
     ```



  The server requires the Everything SDK DLL to be available:

  Environment variable:
     ```
     EVERYTHING_SDK_PATH=path\to\Everything64.dll
     ```



  Add this to your `claude_desktop_config.json`:

  ```json
  "mcpServers": {
    "everything-search": {
      "command": "uv",
      "args": ["--directory", "path/to/mcp-everything-search/src/mcp_server_everything_search", "run", "mcp-server-everything-search"],
      "env": {
        "EVERYTHING_SDK_PATH": "path/to/Everything64.dll"
      }
    }
  }
  ```





  Search for files and folders using Everything SDK.

  Parameters:
  - `query` (required): Search query string
  - `max_results` (optional): Maximum number of results to return (default: 100, max: 1000)

  Example:
  ```json
  {
    "query": "*.py",
    "max_results": 50
  }
  ```

  Response includes:
  - File/folder path
  - File size in bytes
  - Last modified date



  This MCP server is licensed under the MIT License. See the LICENSE file for details.

rpm_license:
  MIT License  Copyright (c) 2024 Everything Search MCP Server  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: 9bcd4a20d24b20a5f74256c6cb89bc317a5b07e50ca112c79a03e42d10b40f05
name: python-mcp-server-qdrant-help
arch: noarch
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for mcp-server-qdrant
url: https://pypi.org/project/mcp-server-qdrant/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-server-qdrant-0.5.2-1.src.rpm
location_href: Packages/python-mcp-server-qdrant-help-0.5.2-1.noarch.rpm
checksum_type: sha256
description:
  [![smithery badge](https://smithery.ai/badge/mcp-server-qdrant)](https://smithery.ai/protocol/mcp-server-qdrant)

  > The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you’re building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need.

  This repository is an example of how to create a MCP server for [Qdrant](https://qdrant.tech/), a vector search engine.



  A basic Model Context Protocol server for keeping and retrieving memories in the Qdrant vector search engine.
  It acts as a semantic memory layer on top of the Qdrant database.





  1. `qdrant-store-memory`
     - Store a memory in the Qdrant database
     - Input:
       - `information` (string): Memory to store
     - Returns: Confirmation message
  2. `qdrant-find-memories`
     - Retrieve a memory from the Qdrant database
     - Input:
       - `query` (string): Query to retrieve a memory
     - Returns: Memories stored in the Qdrant database as separate messages





  When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed to directly run *mcp-server-qdrant*.

  ```shell
  uv run mcp-server-qdrant \
    --qdrant-url "http://localhost:6333" \
    --qdrant-api-key "your_api_key" \
    --collection-name "my_collection" \
    --fastembed-model-name "sentence-transformers/all-MiniLM-L6-v2"
  ```



  To install Qdrant MCP Server for Claude Desktop automatically via [Smithery](https://smithery.ai/protocol/mcp-server-qdrant):

  ```bash
  npx @smithery/cli install mcp-server-qdrant --client claude
  ```



  To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:

  ```json
  {
    "qdrant": {
      "command": "uvx",
      "args": [
        "mcp-server-qdrant",
        "--qdrant-url",
        "http://localhost:6333",
        "--qdrant-api-key",
        "your_api_key",
        "--collection-name",
        "your_collection_name"
      ]
    }
  }
  ```

  Replace `http://localhost:6333`, `your_api_key` and `your_collection_name` with your Qdrant server URL, Qdrant API key
  and collection name, respectively. The use of API key is optional, but recommended for security reasons, and depends on
  the Qdrant server configuration.

  This MCP server will automatically create a collection with the specified name if it doesn't exist.

  By default, the server will use the `sentence-transformers/all-MiniLM-L6-v2` embedding model to encode memories.
  For the time being, only [FastEmbed](https://qdrant.github.io/fastembed/) models are supported, and you can change it
  by passing the `--fastembed-model-name` argument to the server.



  To use a local mode of Qdrant, you can specify the path to the database using the `--qdrant-local-path` argument:

  ```json
  {
    "qdrant": {
      "command": "uvx",
      "args": [
        "mcp-server-qdrant",
        "--qdrant-local-path",
        "/path/to/qdrant/database",
        "--collection-name",
        "your_collection_name"
      ]
    }
  }
  ```

  It will run Qdrant local mode inside the same process as the MCP server. Although it is not recommended for production.



  The configuration of the server can be also done using environment variables:

  - `QDRANT_URL`: URL of the Qdrant server, e.g. `http://localhost:6333`
  - `QDRANT_API_KEY`: API key for the Qdrant server
  - `COLLECTION_NAME`: Name of the collection to use
  - `FASTEMBED_MODEL_NAME`: Name of the FastEmbed model to use
  - `QDRANT_LOCAL_PATH`: Path to the local Qdrant database

  You cannot provide `QDRANT_URL` and `QDRANT_LOCAL_PATH` at the same time.



  This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software,
  subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project
  repository.


pkgId: 700302dcd178aab5026469d2f08d9cd2e11579cf9fc2ccb3874e0e277200b1e1
name: python-mcp-server-rememberizer-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for mcp-server-rememberizer
url: https://pypi.org/project/mcp-server-rememberizer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-server-rememberizer-0.1.2-1.src.rpm
location_href: Packages/python-mcp-server-rememberizer-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A [Model Context Protocol](https://www.anthropic.com/news/model-context-protocol) server for interacting with Rememberizer's document and knowledge management API. This server enables Large Language Models to search, retrieve, and manage documents and integrations through Rememberizer.

  Please note that `mcp-server-rememberizer` is currently in development and the functionality may be subject to change.





  The server provides access to two types of resources: Documents or Slack discussions



  1. `rememberizer_search`

     - Search for documents by semantic similarity
     - Input:
       - `q` (string): Up to a 400-word sentence to find semantically similar chunks of knowledge
       - `n` (integer, optional): Number of similar documents to return (default: 5)
       - `from` (string, optional): Start date in ISO 8601 format with timezone (e.g., 2023-01-01T00:00:00Z). Use this to filter results from a specific date (default: None)
       - `to` (string, optional): End date in ISO 8601 format with timezone (e.g., 2024-01-01T00:00:00Z). Use this to filter results until a specific date (default: None)
     - Returns: Search results as text output

  2. `rememberizer_agentic_search`

     - Search for documents by semantic similarity with LLM Agents augmentation
     - Input:
       - `query` (string): Up to a 400-word sentence to find semantically similar chunks of knowledge. This query can be augmented by our LLM Agents for better results.
       - `n_chunks` (integer, optional): Number of similar documents to return (default: 5)
       - `user_context` (string, optional): The additional context for the query. You might need to summarize the conversation up to this point for better context-awared results (default: None)
       - `from` (string, optional): Start date in ISO 8601 format with timezone (e.g., 2023-01-01T00:00:00Z). Use this to filter results from a specific date (default: None)
       - `to` (string, optional): End date in ISO 8601 format with timezone (e.g., 2024-01-01T00:00:00Z). Use this to filter results until a specific date (default: None)
     - Returns: Search results as text output

  3. `rememberizer_list_integrations`

     - List available data source integrations
     - Input: None required
     - Returns: List of available integrations

  4. `rememberizer_account_information`

     - Get account information
     - Input: None required
     - Returns: Account information details

  5. `rememberizer_list_documents`

     - Retrieves a paginated list of all documents
     - Input:
       - `page` (integer, optional): Page number for pagination, starts at 1 (default: 1)
       - `page_size` (integer, optional): Number of documents per page, range 1-1000 (default: 100)
     - Returns: List of documents





  When using [`uv`](https://docs.astral.sh/uv/), no specific installation is needed. Use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run _mcp-server-rememberizer_.





  The following environment variables are required:

  - `REMEMBERIZER_API_TOKEN`: Your Rememberizer API token

  You can register an API key by create your own [Common Knowledge in Rememberizer](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).



  Add this to your `claude_desktop_config.json`:

  ```json
  "mcpServers": {
    "rememberizer": {
        "command": "uvx",
        "args": ["mcp-server-rememberizer"],
        "env": {
          "REMEMBERIZER_API_TOKEN": "your_rememberizer_api_token"
        }
      },
  }
  ```



  Since MCP servers run over stdio, debugging can be challenging. For the best debugging
  experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).

  You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

  ```bash
  npx @modelcontextprotocol/inspector uv --directory /path/to/directory/mcp-servers-rememberizer/src/mcp_server_rememberizer run mcp-server-rememberizer
  ```

  Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.



  This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.


pkgId: 3507b1983b9d9ed7da470aa08262bae3ce1d80664e7cdf87a30216ff33581722
name: python-mcp-shell-server-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for mcp-shell-server
url: https://pypi.org/project/mcp-shell-server/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-shell-server-1.0.2-1.src.rpm
location_href: Packages/python-mcp-shell-server-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/tumf/mcp-shell-server/branch/main/graph/badge.svg)](https://codecov.io/gh/tumf/mcp-shell-server)

  A secure shell command execution server implementing the Model Context Protocol (MCP). This server allows remote execution of whitelisted shell commands with support for stdin input.



  * **Secure Command Execution**: Only whitelisted commands can be executed
  * **Standard Input Support**: Pass input to commands via stdin
  * **Comprehensive Output**: Returns stdout, stderr, exit status, and execution time
  * **Shell Operator Safety**: Validates commands after shell operators (; , &&, ||, |)
  * **Timeout Control**: Set maximum execution time for commands





  ```shell
  code ~/Library/Application\ Support/Claude/claude_desktop_config.json
  ```

  ```json
  {
    "mcpServers": {
      "shell": {
        "command": "uvx",
        "args": [
          "mcp-shell-server"
        ],
        "env": {
          "ALLOW_COMMANDS": "ls,cat,pwd,grep,wc,touch,find"
        }
      },
    }
  }
  ```





  ```shell
  code ~/Library/Application\ Support/Claude/claude_desktop_config.json
  ```

  ```json
  {
    "mcpServers": {
      "shell": {
        "command": "uv",
        "args": [
          "--directory",
          ".",
          "run",
          "mcp-shell-server"
        ],
        "env": {
          "ALLOW_COMMANDS": "ls,cat,pwd,grep,wc,touch,find"
        }
      },
    }
  }
  ```



  ```bash
  pip install mcp-shell-server
  ```





  ```bash
  ALLOW_COMMANDS="ls,cat,echo" uvx mcp-shell-server

  ALLOWED_COMMANDS="ls,cat,echo" uvx mcp-shell-server
  ```

  The `ALLOW_COMMANDS` (or its alias `ALLOWED_COMMANDS` ) environment variable specifies which commands are allowed to be executed. Commands can be separated by commas with optional spaces around them.

  Valid formats for ALLOW_COMMANDS or ALLOWED_COMMANDS:

  ```bash
  ALLOW_COMMANDS="ls,cat,echo"          # Basic format
  ALLOWED_COMMANDS="ls ,echo, cat"      # With spaces (using alias)
  ALLOW_COMMANDS="ls,  cat  , echo"     # Multiple spaces
  ```



  ```python

  {
      "command": ["ls", "-l", "/tmp"]
  }


  {
      "command": ["cat"],
      "stdin": "Hello, World!"
  }


  {
      "command": ["long-running-process"],
      "timeout": 30  # Maximum execution time in seconds
  }


  {
      "command": ["grep", "-r", "pattern"],
      "directory": "/path/to/search",
      "timeout": 60
  }
  ```



  Successful response:

  ```json
  {
      "stdout": "command output",
      "stderr": "",
      "status": 0,
      "execution_time": 0.123
  }
  ```

  Error response:

  ```json
  {
      "error": "Command not allowed: rm",
      "status": 1,
      "stdout": "",
      "stderr": "Command not allowed: rm",
      "execution_time": 0
  }
  ```



  The server implements several security measures:

  1. **Command Whitelisting**: Only explicitly allowed commands can be executed
  2. **Shell Operator Validation**: Commands after shell operators (;, &&, ||, |) are also validated against the whitelist
  3. **No Shell Injection**: Commands are executed directly without shell interpretation





  1. Clone the repository

  ```bash
  git clone https://github.com/yourusername/mcp-shell-server.git
  cd mcp-shell-server
  ```

  2. Install dependencies including test requirements

  ```bash
  pip install -e ".[test]"
  ```



  ```bash
  pytest
  ```





  | Field     | Type       | Required | Description                                   |
  |-----------|------------|----------|-----------------------------------------------|
  | command   | string[]   | Yes      | Command and its arguments as array elements   |
  | stdin     | string     | No       | Input to be passed to the command            |
  | directory | string     | No       | Working directory for command execution       |
  | timeout   | integer    | No       | Maximum execution time in seconds             |



  | Field           | Type    | Description                                |
  |----------------|---------|---------------------------------------------|
  | stdout         | string  | Standard output from the command           |
  | stderr         | string  | Standard error output from the command     |
  | status         | integer | Exit status code                           |
  | execution_time | float   | Time taken to execute (in seconds)         |
  | error          | string  | Error message (only present if failed)     |



  * Python 3.11 or higher
  * mcp>=1.1.0



  MIT License - See LICENSE file for details


pkgId: cd51e39db43866b3b3490e6879a2fd15fa962a357237bfa4d646a33c084e0b12
name: python-mcp-simple-pubmed-help
arch: noarch
version: 0.1.10
epoch: 0
release: 1
summary: Development documents and examples for mcp-simple-pubmed
url: https://github.com/andybrandt/mcp-simple-pubmed
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-simple-pubmed-0.1.10-1.src.rpm
location_href: Packages/python-mcp-simple-pubmed-help-0.1.10-1.noarch.rpm
checksum_type: sha256
description:
  An MCP server that provides access to PubMed articles through the Entrez API.



  - Search PubMed database using keywords
  - Access article abstracts
  - Download full text when available (for open access articles available directly on PubMed)

  Please note that the tool returns XML-ized version of full text. It is however more useful for AIs than a "human readable" text would have been as it gives them additional information about document's structure. At least, this is what Claude 3.5 Sonnet said he prefers.

  Please also note that inability of this tool and possibly other tools to deliver a paper's full text may not be due to the fact that it is not available. When testing this tool I came across a paper that did not have full text on PubMed and when Claude accessed the publication URL (which we did get through DOI) using fetch he did get a "forbidden” error. However, I was able to access the very same page using a regular browser.

  In other words if your AI assistant is not able to get the full text of a paper using this tool it is worth trying manually with a regular web browser.

  Finally, this tool of course can’t give you access to paywalled/paid papers. You may be able to read them through your library access or – as a last resort – through a certain site that strives to make publicly funded research freely available.



  ```bash
  pip install mcp-simple-pubmed
  ```



  The server requires the following environment variables:

  - `PUBMED_EMAIL`: Your email address (required by NCBI)
  - `PUBMED_API_KEY`: Optional API key for higher rate limits

  The standard rate limit is 3 requests / second. No rate limiting was implemented, as it is highly unlikely in the typical usage scenario that your AI would generate more traffic. If you need it, you can [register for an API key](https://www.ncbi.nlm.nih.gov/account/) which will give you 10 requests / second. Read about [this on NCBI pages](https://www.ncbi.nlm.nih.gov/books/NBK25497/#chapter2.Usage_Guidelines_and_Requiremen).



  Add to your Claude Desktop configuration (`claude_desktop_config.json`):

  (Mac OS)

  ```json
  {
    "mcpServers": {
      "simple-pubmed": {
        "command": "python",
        "args": ["-m", "mcp_simple_pubmed"],
        "env": {
          "PUBMED_EMAIL": "your-email@example.com",
          "PUBMED_API_KEY": "your-api-key"
        }
      }
    }
  }
  ```

  (Windows)


  ```json
  {
    "mcpServers": {
      "simple-pubmed": {
        "command": "C:\\Users\\YOUR_USERNAME\\AppData\\Local\\Programs\\Python\\Python311\\python.exe",
        "args": [
          "-m",
          "mcp_simple_pubmed"
        ],
        "env": {
          "PUBMED_EMAIL": "your-email@example.com",
          "PUBMED_API_KEY": "your-api-key"
        }
      }
    }
  }
  ```



  MIT License


pkgId: 271b6ea08e30e350661c4d05a0b8ae2fe0e58e88f39f2aaceb5f51974e6c4824
name: python-mcp-text-editor-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mcp-text-editor
url: https://pypi.org/project/mcp-text-editor/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mcp-text-editor-1.0.0-1.src.rpm
location_href: Packages/python-mcp-text-editor-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/tumf/mcp-text-editor/graph/badge.svg?token=52D51U0ZUR)](https://codecov.io/gh/tumf/mcp-text-editor)

  A Model Context Protocol (MCP) server that provides text file editing capabilities through a standardized API.



  MCP Text Editor Server is designed to facilitate safe and efficient text file operations in a client-server architecture. It implements the Model Context Protocol, ensuring reliable file editing with robust conflict detection and resolution. This makes it ideal for applications requiring synchronized file access, such as collaborative editing tools, automated text processing systems, or any scenario where multiple processes need to modify text files safely.



  - Safe concurrent editing with hash-based validation
  - Efficient partial file access with line-range specifications
  - Atomic multi-file operations
  - Robust error handling and recovery mechanisms




  - Get text file contents with line range specification
  - Read multiple ranges from multiple files in a single operation
  - Edit text file contents with conflict detection
  - Support for multiple file operations
  - Proper handling of concurrent edits with hash-based validation
  - Line-based patch application with correct handling of line number shifts
  - Robust error handling and validation
  - Memory-efficient processing of large files




  - Python 3.11 or higher
  - POSIX-compliant operating system (Linux, macOS, etc.) or Windows
  - Sufficient disk space for text file operations
  - File system permissions for read/write operations


  1. Install Python 3.11+

  ```bash
  pyenv install 3.11.6
  pyenv local 3.11.6
  ```

  2. Install uv (recommended) or pip

  ```bash
  curl -LsSf https://astral.sh/uv/install.sh | sh
  ```

  3. Create virtual environment and install dependencies

  ```bash
  uv venv
  source .venv/bin/activate  # On Windows: .venv\Scripts\activate
  uv pip install -e ".[dev]"
  ```



  ```bash
  pip install -e .
  ```

  For development:

  ```bash
  pip install -e ".[dev]"
  ```



  Start the server:

  ```bash
  python -m mcp_text_editor
  ```



  The server provides two main tools:



  Get the contents of one or more text files with line range specification.

  **Single Range Request:**

  ```json
  {
    "file_path": "path/to/file.txt",
    "line_start": 1,
    "line_end": 10
  }
  ```

  **Multiple Ranges Request:**

  ```json
  {
    "files": [
      {
        "file_path": "file1.txt",
        "ranges": [
          {"start": 1, "end": 10},
          {"start": 20, "end": 30}
        ]
      },
      {
        "file_path": "file2.txt",
        "ranges": [
          {"start": 5, "end": 15}
        ]
      }
    ]
  }
  ```

  Parameters:
  - `file_path`: Path to the text file
  - `line_start`/`start`: Line number to start from (1-based)
  - `line_end`/`end`: Line number to end at (inclusive, null for end of file)

  **Single Range Response:**

  ```json
  {
    "contents": "File contents",
    "line_start": 1,
    "line_end": 10,
    "hash": "sha256-hash-of-contents",
    "file_lines": 50,
    "file_size": 1024
  }
  ```

  **Multiple Ranges Response:**

  ```json
  {
    "file1.txt": [
      {
        "content": "Lines 1-10 content",
        "start_line": 1,
        "end_line": 10,
        "hash": "sha256-hash-1",
        "total_lines": 50,
        "content_size": 512
      },
      {
        "content": "Lines 20-30 content",
        "start_line": 20,
        "end_line": 30,
        "hash": "sha256-hash-2",
        "total_lines": 50,
        "content_size": 512
      }
    ],
    "file2.txt": [
      {
        "content": "Lines 5-15 content",
        "start_line": 5,
        "end_line": 15,
        "hash": "sha256-hash-3",
        "total_lines": 30,
        "content_size": 256
      }
    ]
  }
  ```



  Edit text file contents with conflict detection. Supports editing multiple files in a single operation.

  **Request Format:**

  ```json
  {
    "files": [
      {
        "path": "file1.txt",
        "hash": "sha256-hash-from-get-contents",
        "patches": [
          {
            "line_start": 5,
            "line_end": 8,
            "contents": "New content for lines 5-8\n"
          },
          {
            "line_start": 15,
            "line_end": 15,
            "contents": "Single line replacement\n"
          }
        ]
      },
      {
        "path": "file2.txt",
        "hash": "sha256-hash-from-get-contents",
        "patches": [
          {
            "line_start": 1,
            "line_end": 3,
            "contents": "Replace first three lines\n"
          }
        ]
      }
    ]
  }
  ```

  Important Notes:
  1. Always get the current hash using get_text_file_contents before editing
  2. Patches are applied from bottom to top to handle line number shifts correctly
  3. Patches must not overlap within the same file
  4. Line numbers are 1-based
  5. If original content ends with newline, ensure patch content also ends with newline

  **Success Response:**

  ```json
  {
    "file1.txt": {
      "result": "ok",
      "hash": "sha256-hash-of-new-contents"
    },
    "file2.txt": {
      "result": "ok",
      "hash": "sha256-hash-of-new-contents"
    }
  }
  ```

  **Error Response:**

  ```json
  {
    "file1.txt": {
      "result": "error",
      "reason": "File not found",
      "hash": null
    },
    "file2.txt": {
      "result": "error",
      "reason": "Content hash mismatch - file was modified",
      "hash": "current-hash",
      "content": "Current file content"
    }
  }
  ```



  1. Get current content and hash:

  ```python
  contents = await get_text_file_contents({
      "files": [
          {
              "file_path": "file.txt",
              "ranges": [{"start": 1, "end": null}]  # Read entire file
          }
      ]
  })
  ```

  2. Edit file content:

  ```python
  result = await edit_text_file_contents({
      "files": [
          {
              "path": "file.txt",
              "hash": contents["file.txt"][0]["hash"],
              "patches": [
                  {
                      "line_start": 5,
                      "line_end": 8,
                      "contents": "New content\n"
                  }
              ]
          }
      ]
  })
  ```

  3. Handle conflicts:

  ```python
  if result["file.txt"]["result"] == "error":
      if "hash mismatch" in result["file.txt"]["reason"]:
          
          
          pass
  ```



  The server handles various error cases:
  - File not found
  - Permission errors
  - Hash mismatches (concurrent edit detection)
  - Invalid patch ranges
  - Overlapping patches
  - Line number out of bounds



  - File Path Validation: The server validates all file paths to prevent directory traversal attacks
  - Access Control: Proper file system permissions should be set to restrict access to authorized directories
  - Hash Validation: All file modifications are validated using SHA-256 hashes to prevent race conditions
  - Input Sanitization: All user inputs are properly sanitized and validated
  - Error Handling: Sensitive information is not exposed in error messages





  1. Permission Denied
     - Check file and directory permissions
     - Ensure the server process has necessary read/write access

  2. Hash Mismatch Errors
     - The file was modified by another process
     - Fetch latest content and retry the operation

  3. Connection Issues
     - Verify the server is running and accessible
     - Check network configuration and firewall settings

  4. Performance Issues
     - Consider using smaller line ranges for large files
     - Monitor system resources (memory, disk space)





  1. Clone the repository
  2. Create and activate a Python virtual environment
  3. Install development dependencies: `pip install -e ".[dev]"`
  4. Run tests: `pytest`



  - Ruff for linting
  - Black for code formatting
  - isort for import sorting
  - mypy for type checking
  - pytest-cov for test coverage



  Tests are located in the `tests` directory and can be run with pytest:

  ```bash

  pytest


  pytest --cov=mcp_text_editor --cov-report=term-missing


  pytest tests/test_text_editor.py -v
  ```

  Current test coverage: 90%



  ```
  mcp-text-editor/
  ├── mcp_text_editor/
  │   ├── __init__.py
  │   ├── __main__.py      # Entry point
  │   ├── models.py        # Data models
  │   ├── server.py        # MCP Server implementation
  │   ├── service.py       # Core service logic
  │   └── text_editor.py   # Text editor functionality
  ├── tests/               # Test files
  └── pyproject.toml       # Project configuration
  ```



  MIT



  1. Fork the repository
  2. Create a feature branch
  3. Make your changes
  4. Run tests and code quality checks
  5. Submit a pull request



  This project uses Python type hints throughout the codebase. Please ensure any contributions maintain this.



  All error cases should be handled appropriately and return meaningful error messages. The server should never crash due to invalid input or file operations.



  New features should include appropriate tests. Try to maintain or improve the current test coverage.



  All code should be formatted with Black and pass Ruff linting. Import sorting should be handled by isort.


