# packages

pkgId: ca3bd4cb0ab0fd0fda644f880fa7c5a7002431dd871f7f40c0898509da8c74a0
name: python-waylay-sdk-rules-help
arch: noarch
version: 6.12.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-rules
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-rules-6.12.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-rules-help-6.12.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  The REST api to manage rule tasks and rule templates in the Waylay platform.

  This Python package is automatically generated based on the
  Waylay Rules OpenAPI specification (API version: 6.12.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/rules.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Rules api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-rules-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-rules` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-rules]` will additionally install the types package `waylay-sdk-rules-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _rules_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-rules` to only install api support for _rules_.
  - `pip install waylay-sdk-rules[types]` to additionally install type support for _rules_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.rules.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.rules.about.get(
      )
      print("The response of rules.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling rules.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: f5986f0f442683b74f32ff5a9a0804260ed86b530c608167bbf9415629ed1f43
name: python-waylay-sdk-rules-types-help
arch: noarch
version: 6.12.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-rules-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-rules-types-6.12.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-rules-types-help-6.12.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  The REST api to manage rule tasks and rule templates in the Waylay platform.

  This Python package is automatically generated based on the
  Waylay Rules OpenAPI specification (API version: 6.12.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/rules.html).

  It is considered an extension of the waylay-sdk-rules package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-rules`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-rules` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-rules]` will additionally install the types package `waylay-sdk-rules-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _rules_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-rules` to only install api support for _rules_.
  - `pip install waylay-sdk-rules[types]` to additionally install type support for _rules_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.rules.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.rules.about.get(
      )
      print("The response of rules.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling rules.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 49825d2c828fc30783e6966935054dc8c94fb124cf58f654e354b22f451d8a79
name: python-waylay-sdk-storage-help
arch: noarch
version: 0.5.2.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-storage
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-storage-0.5.2.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-storage-help-0.5.2.20241025-1.noarch.rpm
checksum_type: sha256
description:
  Manage storage buckets and subscriptions.


  This Python package is automatically generated based on the
  Waylay Storage OpenAPI specification (API version: 0.5.2)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/storage.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Storage api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-storage-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-storage` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-storage]` will additionally install the types package `waylay-sdk-storage-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _storage_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-storage` to only install api support for _storage_.
  - `pip install waylay-sdk-storage[types]` to additionally install type support for _storage_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.storage.models.tenant_status_report import TenantStatusReport
  try:
      
      
      api_response = await waylay_client.storage.about.status(
          
          query = {
              'include_buckets': True
              'include_queues': True
              'include_disk_usage': False
          },
      )
      print("The response of storage.about.status:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling storage.about.status: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 937e0ac9f7d848cd29835f4ff7abfe6d1726d72215371448270222b166264c70
name: python-waylay-sdk-storage-types-help
arch: noarch
version: 0.5.2.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-storage-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-storage-types-0.5.2.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-storage-types-help-0.5.2.20241025-1.noarch.rpm
checksum_type: sha256
description:
  Manage storage buckets and subscriptions.


  This Python package is automatically generated based on the
  Waylay Storage OpenAPI specification (API version: 0.5.2)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/storage.html).

  It is considered an extension of the waylay-sdk-storage package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-storage`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-storage` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-storage]` will additionally install the types package `waylay-sdk-storage-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _storage_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-storage` to only install api support for _storage_.
  - `pip install waylay-sdk-storage[types]` to additionally install type support for _storage_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.storage.models.tenant_status_report import TenantStatusReport
  try:
      
      
      api_response = await waylay_client.storage.about.status(
          
          query = {
              'include_buckets': True
              'include_queues': True
              'include_disk_usage': False
          },
      )
      print("The response of storage.about.status:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling storage.about.status: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 34fb05ec7a9cc327e95549acde642b9a9bc5699c605ae2ab76d3ea15652eeadf
name: python-wbml-help
arch: noarch
version: 0.4.2
epoch: 0
release: 1
summary: Development documents and examples for wbml
url: https://github.com/wesselb/wbml
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wbml-0.4.2-1.src.rpm
location_href: Packages/python-wbml-help-0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/wesselb/wbml/workflows/CI/badge.svg?branch=master)](https://github.com/wesselb/wbml/actions?query=workflow%3ACI)
  [![Coverage Status](https://coveralls.io/repos/github/wesselb/wbml/badge.svg?branch=master&service=github)](https://coveralls.io/github/wesselb/wbml?branch=master)
  [![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://wesselb.github.io/wbml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Machine learning stuff



  See [the instructions here](https://gist.github.com/wesselb/4b44bf87f3789425f96e26c4308d0adc).
  Then simply

  ```
  pip install wbml
  ```


pkgId: a27dd500b18a71c5ad0f485569b15ccee5a07f1d80820c7eedcd0a2a507580ec
name: python-wbpUFO-help
arch: noarch
version: 0.2.16
epoch: 0
release: 1
summary: Development documents and examples for wbpUFO
url: https://gitlab.com/workbench2/workbench-plugins/wbpUFO
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wbpUFO-0.2.16-1.src.rpm
location_href: Packages/python-wbpUFO-help-0.2.16-1.noarch.rpm
checksum_type: sha256
description:
  UFO plugin for [Workbench](https://pypi.org/project/wbBase/) applications.

  This plugin provides Workbench document templates for fonts in UFO source format:

  As well as a document view to view and edit fonts in these formats.




  ```shell
  pip install wbpUFO
  ```

  Installing this plugin registers an entry point
  in the group "*wbbase.plugin*" named "*ufo*".

  To use the plugin in your application,
  add it to your *application.yml* file as follows:
  ```yaml
  AppName: myApp
  Plugins:
  - Name: ufo
  ```



  For details read the [Documentation](https://workbench2.gitlab.io/workbench-plugins/wbpUFO).


pkgId: e91d718c4a50b265f2edd9af01bc7bc68567d3ef12a0e20990315d6b6397c399
name: python-wcgw-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for wcgw
url: https://github.com/rusiaaman/wcgw
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wcgw-2.2.0-1.src.rpm
location_href: Packages/python-wcgw-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  - Claude - An MCP server on claude desktop for autonomous shell, coding and desktop control agent. (mac only)
  - Chatgpt - Allows custom gpt to talk to your shell via a relay server. (linux or mac)


  ⚠️ Warning: do not use this repo if you aren't scared of "Autonomous shell command execution"

  [![Tests](https://github.com/rusiaaman/wcgw/actions/workflows/python-tests.yml/badge.svg?branch=main)](https://github.com/rusiaaman/wcgw/actions/workflows/python-tests.yml)
  [![Mypy strict](https://github.com/rusiaaman/wcgw/actions/workflows/python-types.yml/badge.svg?branch=main)](https://github.com/rusiaaman/wcgw/actions/workflows/python-types.yml)
  [![Build](https://github.com/rusiaaman/wcgw/actions/workflows/python-publish.yml/badge.svg)](https://github.com/rusiaaman/wcgw/actions/workflows/python-publish.yml)



  - [9 Dec 2024] [Vscode extension to paste context on Claude app](https://marketplace.visualstudio.com/items?itemName=AmanRusia.wcgw)

  - [01 Dec 2024] Removed author hosted relay server for chatgpt.

  - [26 Nov 2024] Introduced claude desktop support through mcp



  - ⚡ **Full Shell Access**: No restrictions, complete control.
  - ⚡ **Desktop control on Claude**: Screen capture, mouse control, keyboard control on claude desktop (on mac with docker linux)
  - ⚡ **Create, Execute, Iterate**: Ask claude to keep running compiler checks till all errors are fixed, or ask it to keep checking for the status of a long running command till it's done.
  - ⚡ **Large file edit**: Supports large file incremental edits to avoid token limit issues. Faster than full file write.
  - ⚡ **Interactive Command Handling**: Supports interactive commands using arrow keys, interrupt, and ansi escape sequences.
  - ⚡ **REPL support**: [beta] Supports python/node and other REPL execution.



  - Solve problem X using python, create and run test cases and fix any issues. Do it in a temporary directory
  - Find instances of code with X behavior in my repository
  - Git clone https://github.com/my/repo in my home directory, then understand the project, set up the environment and build
  - Create a golang htmx tailwind webapp, then open browser to see if it works (use with puppeteer mcp)
  - Edit or update a large file
  - In a separate branch create feature Y, then use github cli to create a PR to original branch
  - Command X is failing in Y directory, please run and fix issues
  - Using X virtual environment run Y command
  - Using cli tools, create build and test an android app. Finally run it using emulator for me to use
  - Fix all mypy issues in my repo at X path.
  - Using 'screen' run my server in background instead, then run another api server in bg, finally run the frontend build. Keep checking logs for any issues in all three
  - Create repo wide unittest cases. Keep iterating through files and creating cases. Also keep running the tests after each update. Do not modify original code.



  First install `uv` https://docs.astral.sh/uv/getting-started/installation/#installation-methods

  Then update `claude_desktop_config.json` (~/Library/Application Support/Claude/claude_desktop_config.json)

  ```json
  {
    "mcpServers": {
      "wcgw": {
        "command": "uv",
        "args": [
          "tool",
          "run",
          "--from",
          "wcgw@latest",
          "--python",
          "3.12",
          "wcgw_mcp"
        ]
      }
    }
  }
  ```

  Then restart claude app.

  _If there's an error in setting up_

  - Make sure `uv` in the system PATH by running `uv --version` and also ensure `uv tool run wcgw --version` works globally.
    Otherwise, re-install uv and follow instructions to add it into your .zshrc or .bashrc
  - If there's still an issue, check that `uv tool run --from wcgw@latest --python 3.12 wcgw_mcp` runs in your terminal. It should have no output and shouldn't exit.
  - Debug the mcp server using `npx @modelcontextprotocol/inspector@0.1.7 uv tool run --from wcgw@latest --python 3.12 wcgw_mcp`



  Computer use is disabled by default. Add `--computer-use` to enable it. This will add necessary tools to Claude including ScreenShot, Mouse and Keyboard control.

  ```json
  {
    "mcpServers": {
      "wcgw": {
        "command": "uv",
        "args": [
          "tool",
          "run",
          "--from",
          "wcgw@latest",
          "--python",
          "3.12",
          "wcgw_mcp",
          "--computer-use"
        ]
      }
    }
  }
  ```

  Claude will be able to connect to any docker container with linux environment. Native system control isn't supported outside docker.

  You'll need to run a docker image with desktop and optional VNC connection. Here's a demo image:

  ```sh
  docker run -p 6080:6080 ghcr.io/anthropics/anthropic-quickstarts:computer-use-demo-latest
  ```

  Then ask claude desktop app to control the docker os. It'll connect to the docker container and control it.

  Connect to `http://localhost:6080/vnc.html` for desktop view (VNC) of the system running in the docker.

  The following requirements should be installed and working in the linux docker image:

  1. Needs `xdotool` to execute commands on the desktop.
  2. Needs `scrot` to take screenshots.
  3. Needs `convert` from imagemagick to convert images.



  Wait for a few seconds. You should be able to see this icon if everything goes right.

  ![mcp icon](https://github.com/rusiaaman/wcgw/blob/main/static/rocket-icon.png?raw=true)
  over here

  ![mcp icon](https://github.com/rusiaaman/wcgw/blob/main/static/claude-ss.jpg?raw=true)

  Then ask claude to execute shell commands, read files, edit files, run your code, etc.

  If you've run the docker for LLM to access, you can ask it to control the "docker os". If you don't provide the docker container id to it, it'll try to search for available docker using `docker ps` command.



  https://marketplace.visualstudio.com/items?itemName=AmanRusia.wcgw

  Commands:
  - Select a text and press `cmd+'` and then enter instructions. This will switch the app to Claude and paste a text containing your instructions, file path, workspace dir, and the selected text.



  Read here: https://github.com/rusiaaman/wcgw/blob/main/openai.md





  ![computer-use](https://github.com/rusiaaman/wcgw/blob/main/static/computer-use.jpg?raw=true)



  ![example](https://github.com/rusiaaman/wcgw/blob/main/static/example.jpg?raw=true)





  Add `OPENAI_API_KEY` and `OPENAI_ORG_ID` env variables.

  Then run

  `uvx --from wcgw@latest wcgw_local  --limit 0.1` # Cost limit $0.1

  You can now directly write messages or press enter key to open vim for multiline message and text pasting.



  Add `ANTHROPIC_API_KEY` env variable.

  Then run

  `uvx --from wcgw@latest wcgw_local --claude`

  You can now directly write messages or press enter key to open vim for multiline message and text pasting.


pkgId: 2db121b552579061f36b10bdfa7b1a2e2f533093c7ac1f3e9e2578077d2a6da8
name: python-wdoc-help
arch: noarch
version: 2.5.0
epoch: 0
release: 1
summary: Development documents and examples for wdoc
url: https://github.com/thiswillbeyourgithub/wdoc/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wdoc-2.5.0-1.src.rpm
location_href: Packages/python-wdoc-help-2.5.0-1.noarch.rpm
checksum_type: sha256
description:
  ![icon](https://github.com/thiswillbeyourgithub/wdoc/blob/main/images/icon.png?raw=true)

  > *I'm wdoc. I solve RAG problems.*
  > - wdoc, imitating Winston "The Wolf" Wolf

  `wdoc` is a powerful RAG (Retrieval-Augmented Generation) system designed to summarize, search, and query documents across various file types. It's particularly useful for handling large volumes of diverse document types, making it ideal for researchers, students, and professionals dealing with extensive information sources. I was frustrated with all other RAG solutions for querying or summarizing, so I made my perfect solution in a single package.

  *(The online documentation can be found [here](https://wdoc.readthedocs.io/en/stable))*

  * **Goal and project specifications**: `wdoc` uses [LangChain](https://python.langchain.com/) to process and analyze documents. It's capable of querying **tens of thousands** of documents across [various file types](#Supported-filetypes) at the same time. The project also includes a tailored summary feature to help users efficiently keep up with large amounts of information.

  * **Current status**: **Under active development**
      * Used daily by the developer for several months: but still in alpha. **I would greatly benefit from testing by users as it's the quickest way for me to find the many small bugs that are quick to fix.**
      * May have some instabilities, but issues can usually be resolved quickly
      * The main branch is more stable than the dev branch, which offers more features
      * Open to feature requests and pull requests
      * All feedbacks, including reports of typos, are highly appreciated
      * Please open an issue before making a PR, as there may be ongoing improvements in the pipeline

  * **Key Features**:
      * Aims to **support *any* filetypes** and query from all of them at the same time (**15+** are already implemented!)
      * **High recall and specificity**: it was made to find A LOT of documents using carefully designed embedding search then carefully aggregate gradually each answer using semantic batch to produce a single answer that mentions the source pointing to the exact portion of the source document.
      * Supports **virtually any LLM providers**, including local ones, and even with extra layers of security for super secret stuff.
      * Use both an expensive and cheap LLM to make recall as high as possible because we can afford fetching a lot of documents per query (via embeddings)
      * **Finally a *useful* AI powered summary**: get the thought process of the author instead of nebulous takeaways.
      * **Extensible**, this is both a tool and a library.


  - [Ultra short guide for people in a hurry](#ultra-short-guide-for-people-in-a-hurry)
  - [Features](#features)
    - [Roadmap](#roadmap)
    - [Supported filetypes](#supported-filetypes)
    - [Supported tasks](#supported-tasks)
    - [Walkthrough and examples](#walkthrough-and-examples)
  - [Scripts made with wdoc](#scripts-made-with-wdoc)
  - [Getting started](#getting-started)
  - [FAQ](#faq)
  - [Notes](#notes)
    - [Known issues](#known-issues)


  <details>
  <summary>
  Give it to me I am in a hurry!
  </summary>


  ``` zsh
  link="https://situational-awareness.ai/wp-content/uploads/2024/06/situationalawareness.pdf"

  wdoc --path=$link --task=query --filetype="online_pdf" --query="What does it say about alphago?" --query_retrievers='default_multiquery' --top_k=auto_200_500
  ```
  * This will:
      1. parse what's in --path as a link to a pdf to download (otherwise the url could simply be a webpage, but in most cases you can leave it to 'auto' by default as heuristics are in place to detect the most appropriate parser).
      2. cut the text into chunks and create embeddings for each
      3. Take the user query, create embeddings for it ('default') AND ask the default LLM to generate alternative queries and embed those
      4. Use those embeddings to search through all chunks of the text and get the 200 most appropriate documents
      5. Pass each of those documents to the smaller LLM (default: openai/gpt-4o-mini) to tell us if the document seems appropriate given the user query
      6. If More than 90% of the 200 documents are appropriate, then we do another search with a higher top_k and repeat until documents start to be irrelevant OR we it 500 documents.
      7. Then each relevant doc is sent to the strong LLM (by default, openai/gpt-4o) to extract relevant info and give one answer.
      8. Then all those "intermediate" answers are 'semantic batched' (meaning we create embeddings, do hierarchical clustering, then create small batch containing several intermediate answers) and each batch is combined into a single answer.
      9. Rinse and repeat steps 7+8 until we have only one answer, that is returned to the user.

  ``` zsh
  link="https://situational-awareness.ai/wp-content/uploads/2024/06/situationalawareness.pdf"

  wdoc --path=$link --task=summarize --filetype="online_pdf"
  ```
  * This will:
      1. Split the text into chunks
      2. pass each chunk into the strong LLM (by default openai/gpt-4o) for a very low level (=with all details) summary. The format is markdown bullet points for each idea and with logical indentation.
      3. When creating each new chunk, the LLM has access to the previous chunk for context.
      4. All summary are then concatenated and returned to the user

  * For extra large documents like books for example, this summary can be recusively fed to `wdoc` using argument --summary_n_recursion=2 for example.

  * Those two tasks, query and summary, can be combined with --task summarize_then_query which will summarize the document but give you a prompt at the end to ask question in case you want to clarify things.

  * For more, you can jump to the section [Walkthrough and examples](#walkthrough-and-examples)

  </details>


  * **15+ filetypes**: also supports combination to load recursively or define complex heterogenous corpus like a list of files, list of links, using regex, youtube playlists etc. See [Supported filestypes](#Supported-filetypes). All filetype can be seamlessly combined in the same index, meaning you can query your anki collection at the same time as your work PDFs). It supports removing silence from audio files and youtube videos too!
  * **100+ LLMs**: OpenAI, Mistral, Claude, Ollama, Openrouter, etc. Thanks to [litellm](https://docs.litellm.ai/). Personnaly I'm using openrouter's Sonnet 3.5 as strong LLM and openai's gpt-4o-mini as query_eval LLM, with openai embeddings.
  * **Local and Private LLM**: take some measures to make sure no data leaves your computer and goes to an LLM provider: no API keys are used, all `api_base` are user set, cache are isolated from the rest, outgoing connections are censored by overloading sockets, etc.
  * **Advanced RAG to query lots of diverse documents**:
      1. The documents are retrieved using embedding
      2. Then a weak LLM model ("Eve the Evaluator") is used to tell which of those document is not relevant
      3. Then the strong LLM is used to answer ("Anna the Answerer") the question using each individual remaining documents.
      4. Then all relevant answers are combined ("Carl the Combiner") into a single short markdown-formatted answer. Before being combined, they are batched by semantic clusters
      and semantic order using scipy's hierarchical clustering and leaf ordering, this makes it easier for the LLM to combine the answers in a manner that makes bottom up sense.
      `Eve the Evaluator`, `Anna the Answerer` and `Carl the Combiner` are the names given to each LLM in their system prompt, this way you can easily add specific additional instructions to a specific step. There's also `Sam the Summarizer` for summaries and `Raphael the Rephraser` to expand your query.
      5. Each document is identified by a unique hash and the answers are sourced, meaning you know from which document comes each information of the answer.
      * Supports a special syntax like "QE >>>> QA" were QE is a question used to filter the embeddings and QA is the actual question you want answered.
  * **Advanced summary**:
      * Instead of unusable "high level takeaway" points, compress the reasoning, arguments, though process etc of the author into an easy to skim markdown file.
      * The summaries are then checked again n times for correct logical indentation etc.
      * The summary can be in the same language as the documents or directly translated.
  * **Many tasks**: See [Supported tasks](#Supported-tasks).
  * **Trust but verify**: The answer is sourced: `wdoc` keeps track of the hash of each document used in the answer, allowing you to verify each assertion.
  * **Markdown formatted answers and summaries**: using [rich](https://github.com/Textualize/rich).
  * **Sane embeddings**: By default use sophisticated embeddings like [multi query retrievers](https://python.langchain.com/docs/how_to/MultiQueryRetriever) but also include SVM, KNN, parent retriever etc. Customizable.
  * **Fully documented** Lots of docstrings, lots of in code comments, detailed `--help` etc. The full usage can be found in the file [USAGE.md](./wdoc/docs/USAGE.md) or via `python -m wdoc --help`. I work hard to maintain an exhaustive documentation.
  * **Scriptable / Extensible**: You can use `wdoc` in other python project using `--import_mode`. Take a look at the scripts [below](#scripts-made-with-wdoc).
  * **Statically typed**: Runtime type checking. Opt out with an environment flag: `WDOC_TYPECHECKING="disabled / warn / crash" wdoc` (by default: `warn`). Thanks to [beartype](https://beartype.readthedocs.io/en/latest/) it shouldn't even slow down the code!
  * **LLM (and embeddings) caching**: speed things up, as well as index storing and loading (handy for large collections).
  * **Good PDF parsing** PDF parsers are notoriously unreliable, so 15 (!) different loaders are used, and the best according to a parsing scorer is kept. Including table support via [openparse](https://github.com/Filimoa/open-parse/) (no GPU needed by default) or via [UnstructuredPDFLoader](https://python.langchain.com/docs/integrations/document_loaders/unstructured_pdfloader/).
  * **Langfuse support**: If you set the appropriate langfuse environment variables they will be used. See [this guide](https://langfuse.com/docs/integrations/langchain/tracing) or [this one](https://langfuse.com/docs/integrations/litellm/tracing) to learn more (Note: this is disabled if using private_mode to avoid any leaks).
  * **Document filtering**: based on regex for document content or metadata.
  * **Fast**: Parallel document loading, parsing, embeddings, querying, etc.
  * **Shell autocompletion** using [python-fire](https://github.com/google/python-fire/blob/master/docs/using-cli.md#completion-flag)
  * **Notification callback**: Can be used for example to get summaries on your phone using [ntfy.sh](ntfy.sh).
  * **Hacker mindset**: I'm a friendly dev! Just open an issue if you have a feature request or anything else.



  <details>
  <summary>
  Click to read more
  </summary>

  <i>This TODO list is maintained automatically by [MdXLogseqTODOSync](https://github.com/thiswillbeyourgithub/MdXLogseqTODOSync)</i>

  <!-- BEGIN_TODO -->
  - ## Most urgent
      - add more tests
          - add test for the private mode
          - add test for the testing models
          - add test for each loader
      - the logit bias is wrong for openai models: the token is specific to a given family of model
      - rewrite the python API to make it more useable. (also related to https://github.com/thiswillbeyourgithub/wdoc/issues/13)
          - be careful to how to use import_mode
      - make it easy to use wdoc as an openwebui pipeline (also related to https://github.com/thiswillbeyourgithub/wdoc/issues/4)
          - probably by creating a server with fastapi then a quick pipeline file
      - support other vector databases
      - make it easier to use other embeddings API than openai
      - understand why it appears that in some cases the sources id is never properly parsed
          - crash if source got lost  + arg to disable
  - ### Features
      - make it easy to support other embeddings model, right now it seems only openai is easy to use. But litellm does not have an embeddings engine with langchain. Maybe there's one on github?
      - Way to add the title (or all metadata) of a document to its own text. Enabled by default. Because this would allow searching among many documents that don't refer to the original title (for example: material safety datasheets)
          - default value is "author" "page" title"
      - add a /save PATH command to save the chat and metadata to a json file
      - Accept input from stdin, to for example query directly from a manpage
          - make wdoc work if used with shell pipes
      - add image support printing via icat or via the other lib you found last time, would be useful for summaries etc
      - add an audio backend to use the subtitles from a video file directly
      - store the anki images as 'imagekeys' as the idea works for other parsers too
      - add an argument --whole_text to avoid chunking (this would just increase the chunk size to a super large number I guess)
      - add a filetype "custom_parser" and an argument "--custom_parser" containing a path to a python file. Must receive a docdict and a few other things and return a list of documents
          - then make it work with an online search engine for technical things
      - add a langchain code loader that uses aider to get the repomap
          - https://github.com/paul-gauthier/aider/issues/1043#issuecomment-2278486840
      - add a pikepdf loader because it can be used to automatically decrypt pdfs
      - add a query_branching_nb argument that asks an LLM to identify a list of keywords from the intermediate answers, then look again for documents using this keyword and filtering via the weak llm
      - write a script that shows how to use bertopic on the documents of wdoc
      - add a jina web search and async retriever https://jina.ai/news/jina-reader-for-search-grounding-to-improve-factuality-of-llms/
      - add a retriever where the LLM answer without any context
      - add support for readabilipy for parsing html
          - https://github.com/alan-turing-institute/ReadabiliPy
      - add an obsidian loader
          - https://pypi.org/project/obsidiantools/
      - add a /chat command to the prompt, it would enable starting an interactive session directly with the llm
      - make sure to expose loaders and batch_loader to make it easy to import by others
      - find a way to make it work with llm from simonw
      - make images an actual filetype
  - ### Enhancements
      - store the available tasks in a single var in misc.py
      - check that the task search work on things other than anki
      - create a custom custom retriever, derived from multiquery retriever that does actual parallel requests. Right now it's not the case (maybe in async but I don't plan on using async for now). This retriever seems a good part of the slow down.
      - Use an env var to drop_params of litellm
      - add more specific exceptions for file loading error. One exception for all, one for batch and one for individual loader
      - use heuristics to find the best number of clusters when doing semantic reranking
      - arg to use jina v3 embeddings for semantic batching because it allows specifying tasks that seem appropriate for that
      - add an env variable or arg to overload the backend url for whisper. Then set it always for you and mention it there: https://github.com/fedirz/faster-whisper-server/issues/5
      - find a way to set a max cost at which to crash if it exceeds a maximum cost during a query, probably via the price callback
      - anki_profile should be able to be a path
      - store wdoc's version and indexing timestamp in the metadata of the document
      - arg --oneoff that does not trigger the chat after replying. Allowing to not hog all the RAM if ran in multiple terminals for example through SSH
      - add a (high) token threshold above which two texts are not combined but just concatenated in the semantic order. It would avoid it loosing context. Use a --- separator
      - compute the cost of whisper and deepgram
      - use a pydantic basemodel for output instead of a dict
          - same for summaries, it should at least contain the method to substitute the sources and then back
      - investigate storing the vectors in a sqlite3 file
      - make a plugin to llm that looks like file-to-prompt from simonw
      - Always bind a user metadata to litellm for langfuse etc
          - Add more metadata to each request to langfuse more informative
      - add a reranker to better sort the output of the retrievers. Right now with the multiquery it returns way too many and I'm thinking it might be a bad idea to just crop at top_k as I'm doing currently
      - add a status argument that just outputs the logs location and size, the cache location and size, the number of documents etc
      - add the python magic of the file as a file metadata
      - add an env var to specify the threshold for relevant document by the query eval llm
      - find a way to return the evaluations for each document also
      - move retrievers.py in an embeddings folder
      - stop using lambda functions in the chains because it makes the code barely readable
      - when doing recursive summary: tell the model that if it's really sure that there are no modifications to do: it should just reply "EXIT" and it would save time and money instead of waiting for it to copy back the exact content
      - add image parsing as base64 metadata from pdf
      - use multiple small chains instead of one large and complicated and hard to maintain
      - add an arg to bypass query combine, useful for small models
      - break the load_embeddings into sub functions
      - tell the llm to write a special message if the parsing failed or we got a 404 or paywall etc
          - catch this text and crash
      - add check that all metadata is only made of int float and str
      - move the code that filters embeddings inside the embeddings.py file
          - this way we can dynamically refilter using the chat prompt
      - task summary then query should keep in context both the full text and the summary
      - if there's only one intermediate answer, pass it as answer without trying to recombine
      - filter_metadata should support an OR syntax
      - add a --show_models argument to display the list of available models
      - add a way to open the documents automatically, based on platform dirs etc. For ex if okular is installed, open pdfs directly at the right page
          - the best way would be to create opener.py that does a bit like loader but for all filetypes and platforms
      - add an image filetype: it will be either OCR'd using format and/or will be captioned using a multimodal llm, for example gpt4o mini
          - nanollava is a 0.5b that probably can be used for that with proper prompting
      - add a key/val arg to specify the trust we have in a doc, call this metadata context in the prompt
      - add an arg to return just the dict of all documents and embeddings. Notably useful to debug documents
      - use a class for the cli prompt, instead of a dumb function
      - arg to disable eval llm filtering
          - just answer 1 directly if no eval llm is set
      - display the number of documents and tokens in the bottom toolbar
      - add a demo gif
      - investigate asking the LLM to  add leading emojis to the bullet point for quicker reading of summaries
      - see how easy or hard it is to use an async chain
      - ability to cap the search documents capped by a number of tokens instead of a number of documents
      - for anki, allow using a query instead of loading with ankipandas
      - add a "try_all" filetype that will try each filetype and keep the first that works
      - add bespoke-minicheck from ollama to fact check when using RAG: https://ollama.com/library/bespoke-minicheck
          - or via their API directly : https://docs.bespokelabs.ai/bespoke-minicheck/api but they don't seem to properly disclose what they do with the data
      - add a way to use binary faiss index as its as efficient but faster and way more compact
  <!-- END_TODO -->

  </details>


  * **auto**: default, guess the filetype for you
  * **url**: try many ways to load a webpage, with heuristics to find the better parsed one
  * **youtube**: text is then either from the yt subtitles / translation or even better: using whisper / deepgram. Note that youtube subtitles are downloaded with the timecode (so you can ask 'when does the author talks about such and such) but at a lower sampling frequency (instead of one timecode per second, only one per 15s). Youtube chapters are also given as context to the LLM when summarizing, which probably help it a lot.
  * **pdf**: 15 default loaders are implemented, heuristics are used to keep the best one and stop early. Table support via [openparse](https://github.com/Filimoa/open-parse/) or [UnstructuredPDFLoader](https://python.langchain.com/docs/integrations/document_loaders/unstructured_pdfloader/). Easy to add more.
  * **online_pdf**: via URL then treated as a **pdf** (see above)
  * **anki**: any subset of an [anki](https://github.com/ankitects/anki) collection db. `alt` and `title` of images can be shown to the LLM, meaning that if you used [the ankiOCR addon](https://github.com/cfculhane/AnkiOCR) this information will help contextualize the note for the LLM.
  * **string**: the cli prompts you for a text so you can easily paste something, handy for paywalled articles!
  * **txt**: .txt, markdown, etc
  * **text**: send a text content directly as path
  * **local_html**: useful for website dumps
  * **logseq_markdown**: thanks to my other project: [LogseqMarkdownParser](https://github.com/thiswillbeyourgithub/LogseqMarkdownParser) you can use your [Logseq graph](https://github.com/logseq/logseq/)
  * **local_audio**: supports many file formats, can use either OpenAI's whisper or [deepgram](https://deepgram.com). Supports automatically removing silence etc. Note: audio that are too large for whisper (usually >25mb) are automatically split into smaller files, transcribed, then combined. Also, audio transcripts are converted to text containing timestamps at regular intervals, making it possible to ask the LLM when something was said.
  * **local_video**: extract the audio then treat it as **local_audio**
  * **online_media**: use youtube_dl to try to download videos/audio, if fails try to intercept good url candidates using playwright to load the page. Then processed as **local_audio** (but works with video too).
  * **epub**: barely tested because epub is in general a poorly defined format
  * **powerpoint**: .ppt, .pptx, .odp, ...
  * **word**: .doc, .docx, .odt, ...
  * **json_dict**: a text file containing a single json dict.

  * **Recursive types**
      * **youtube playlists**: get the link for each video then process as **youtube**
      * **recursive_paths**: turns a path, a regex pattern and a filetype into all the files found recurisvely, and treated a the specified filetype (for example many PDFs or lots of HTML files etc).
      * **link_file**: turn a text file where each line contains a url into appropriate loader arguments. Supports any link, so for example webpage, link to pdfs and youtube links can be in the same file. Handy for summarizing lots of things!
      * **json_entries**: turns a path to a file where each line is a json **dict**: that contains arguments to use when loading. Example: load several other recursive types. An example can be found in `docs/json_entries_example.json`.
      * **toml_entries**: read a .toml file. An example can be found in `docs/toml_entries_example.toml`.


  * **query** give documents and asks questions about it.
  * **search** only returns the documents and their metadata. For anki it can be used to directly open cards in the browser.
  * **summarize** give documents and read a summary. The summary prompt can be found in `utils/prompts.py`.
  * **summarize_then_query** summarize the document then allow you to query directly about it.



  <details>
  <summary>
  Detailed example
  </summary>

  1. Say you want to ask a question about one pdf, that's simple: `wdoc --task="query" --path="my_file.pdf" --filetype="pdf" --modelname='openai/gpt-4o'`. Note that you could have just let `--filetype="auto"` and it would have worked the same.
  * *Note: By default `wdoc` tries to parse args as kwargs so `wdoc query mydocument What's the age of the captain?` is parsed as `wdoc --task=query --path=mydocument --query "What's the age of the captain?"`. Likewise for summaries. This does not always work so use it only after getting comfortable with `wdoc`.*
  2. You have several pdf? Say you want to ask a question about any pdf contained in a folder, that's not much more complicated : `wdoc --task="query" --path="my/other_dir" --pattern="**/*pdf" --filetype="recursive_paths" --recursed_filetype="pdf" --query="My question about those documents"`. So basically you give as path the path to the dir, as pattern the globbing pattern used to find the files relative to the path, set as filetype "recursive_paths" so that `wdoc` knows what arguments to expect, and specify as recursed_filetype "pdf" so that `wdoc` knows that each found file must be treated as a pdf. You can use the same idea to glob any kind of file supported by `wdoc` like markdown etc. You can even use "auto"! Note that you can either directly ask your question with `--query="my question"`, or wait for an interactive prompt to pop up, or just pass the question as *args like so `wdoc [your kwargs] here is my question`.
  3. You want more? You can write a `.json` file where each line (`#comments` and empty lines are ignored) will be parsed as a list of argument. For example one line could be : `{"path": "my/other_dir", "pattern": "**/*pdf", "filetype": "recursive_paths", "recursed_filetype": "pdf"}`. This way you can use a single json file to specify easily any number of sources. `.toml` files are also supported.
  4. You can specify a "source_tag" metadata to help distinguish between documents you imported. It is EXTREMELY recommended to include a source_tag to any document you want to save: especially if using recursive filetypes. This is because after loading all documents `wdoc` use the source_tag to see if it should continue or crash. If you want to load 10_000 pdf in one go as I do, then it makes sense to continue if some failed to crash but not if a whole source_tag is missing.
  5. Now say you do this with many many documents, as I do, you of course can't wait for the indexing to finish every time you have a question (even though the embeddings are cached). You should then add `--save_embeds_as=your/saving/path` to save all this index in a file. Then simply do `--load_embeds_from=your/saving/path` to quickly ask queries about it!
  6. To know more about each argument supported by each filetype, `wdoc --help`
  7. There is a specific recursive filetype I should mention: `--filetype="link_file"`. Basically the file designated by `--path` should contain in each line (`#comments` and empty lines are ignored) one url, that will be parsed by `wdoc`. I made this so that I can quickly use the "share" button on android from my browser to a text file (so it just appends the url to the file), this file is synced via [syncthing](https://github.com/syncthing/syncthing) to my browser and `wdoc` automatically summarize them and add them to my [Logseq](https://github.com/logseq/logseq/). Note that the url is parsed in each line, so formatting is ignored, for example it works even in markdown bullet point list.
  8. If you want to make sure your data remains private here's an example with ollama: `wdoc --private --llms_api_bases='{"model": "http://localhost:11434", "query_eval_model": "http://localhost:11434"}' --modelname="ollama_chat/gemma:2b" --query_eval_modelname="ollama_chat/gemma:2b" --embed_model="BAAI/bge-m3" my_task`
  9. Now say you just want to summarize [Tim Urban's TED talk on procrastination](https://www.youtube.com/watch?v=arj7oStGLkU): `wdoc --task=summary --path='https://www.youtube.com/watch?v=arj7oStGLkU' --youtube_language="en" --disable_md_printing`:

  <details><summary>Click to see the output</summary>


  > # Summary
  > ## https://www.youtube.com/watch?v=arj7oStGLkU
  > - Let me take a deep breath and summarize this TED talk about procrastination:
  > - [0:00-3:40] Personal experience with procrastination in college:
  >     - Author's pattern with papers: planning to work steadily but actually doing everything last minute
  >     - 90-page senior thesis experience:
  >         - Planned to work steadily over a year
  >         - Actually wrote 90 pages in 72 hours with two all-nighters
  >         - *Jokingly implies* it was brilliant, then admits it was 'very, very bad'
  > - [3:40-6:45] Brain comparison between procrastinators and non-procrastinators:
  >     - Both have a **Rational Decision-Maker**
  >     - Procrastinator's brain also has an **Instant Gratification Monkey**:
  >         - Lives entirely in present moment
  >         - Only cares about 'easy and fun'
  >         - Works fine for animals but problematic for humans in advanced civilization
  >     - **Rational Decision-Maker** capabilities:
  >         - Can visualize future
  >         - See big picture
  >         - Make long-term plans
  > - [6:45-10:55] The procrastinator's system:
  >     - **Dark Playground**:
  >         - Where leisure activities happen at wrong times
  >         - Characterized by guilt, dread, anxiety, self-hatred
  >     - **Panic Monster**:
  >         - Only thing monkey fears
  >         - Awakens near deadlines or threats of public embarrassment
  >         - Enables last-minute productivity
  >     - Personal example with TED talk preparation:
  >         - Procrastinated for months
  >         - Only started working when panic set in
  > - [10:55-13:05] Two types of procrastination:
  >     - Deadline-based procrastination:
  >         - Effects contained due to Panic Monster intervention
  >         - Less harmful long-term
  >     - Non-deadline procrastination:
  >         - More dangerous
  >         - Affects important life areas without deadlines:
  >             - Entrepreneurial pursuits
  >             - Family relationships
  >             - Health
  >             - Personal relationships
  >         - Can cause long-term unhappiness and regrets
  > - [13:05-14:04] Concluding thoughts:
  >     - *Author believes* no true non-procrastinators exist
  >     - Presents **Life Calendar**:
  >         - Shows 90 years in weekly boxes
  >         - Emphasizes limited time available
  >     - Call to action: need to address procrastination 'sometime soon'
  > - Key audience response moments:
  >     - Multiple instances of '(Laughter)' noted throughout
  >     - Particularly strong response from PhD students relating to procrastination issues
  >     - Received thousands of emails after blog post about procrastination
  > Tokens used for https://www.youtube.com/watch?v=arj7oStGLkU: '4936' (in: 4307, out: 629, cost: $0.00063)
  > Total cost of those summaries: 4936 tokens for $0.00063 (estimate was $0.00030)
  > Total time saved by those summaries: 8.8 minutes
  > Done summarizing.

  </details>

  </details>


  *`wdoc` currently requires Python 3.11 to run for now. Make sure that your Python version matches this one or it will not work.*
  1. To install:
      * Using pip: `pip install -U wdoc`
      * Or to get a specific git branch:
          * `dev` branch: `pip install git+https://github.com/thiswillbeyourgithub/wdoc@dev`
          * `main` branch: `pip install git+https://github.com/thiswillbeyourgithub/wdoc@main`
      * You can also use uvx or pipx. But as I'm not experiences with them I don't know if that can cause issues with for example caching etc. Do tell me if you tested it!
          * Using uvx: `uvx wdoc --help`
          * Using pipx: `pipx run wdoc --help`
      * In any case, it is recommended to try to install pdftotext with `pip install -U wdoc[pdftotext]` as well as add fasttext support with `pip install -U wdoc[fasttext]`.
  2. Add the API key for the backend you want as an environment variable: for example `export OPENAI_API_KEY="***my_key***"`
  3. Launch is as easy as using `wdoc --task=query --path=MYDOC [ARGS]`
      * If for some reason this fails, maybe try with `python -m wdoc`. And if everything fails, try with `uvx wdoc@latest`, or as last resort clone this repo and try again after `cd` inside it? Don't hesitate to open an issue.
      * To get shell autocompletion: if you're using zsh: `eval $(cat shell_completions/wdoc_completion.zsh)`. Also provided for `bash` and `fish`. You can generate your own with `wdoc -- --completion MYSHELL > my_completion_file"`.
      * Don't forget that if you're using a lot of documents (notably via recursive filetypes) it can take a lot of time (depending on parallel processing too, but you then might run into memory errors).
  4. To ask questions about a local document: `wdoc query --path="PATH/TO/YOUR/FILE" --filetype="auto"`
      * If you want to reduce the startup time by directly loading the embeddings from a previous run (although the embeddings are always cached anyway): add `--saveas="some/path"` to the previous command to save the generated embeddings to a file and replace with `--loadfrom "some/path"` on every subsequent call.
  5. For more: read the documentation at `wdoc --help`


  * *More to come in [the scripts folder](./scripts/)*
  * [Ntfy Summarizer](scripts/NtfySummarizer): automatically summarize a document from your android phone using [ntfy.sh](ntfy.sh)
  * [TheFiche](scripts/TheFiche): create summaries for specific notions directly as a [logseq](https://github.com/logseq/logseq) page.
  * [FilteredDeckCreator](scripts/FilteredDeckCreator): directly create an [anki](https://ankitects.github.io/) filtered deck from the cards found by `wdoc`.



  <details>
  <summary>
  FAQ
  </summary>

  * **Who is this for?**
      * `wdoc` is for power users who want document querying on steroid, and in depth AI powered document summaries.
  * **What's RAG?**
      * A RAG system (retrieval augmented generation) is basically an LLM powered search through a text corpus.
  * **Why make another RAG system? Can't you use any of the others?**
      * I'm a medical student so I need to be able to ask medical question from **a lot** (tens of thousands) of documents, of different types (epub, pdf, [anki](https://ankitects.github.io/) database, [Logseq](https://github.com/logseq/logseq/), website dump, youtube videos and playlists, recorded conferences, audio files, etc).
  * **Why is `wdoc` better than most RAG system to ask questions on documents?**
      * It uses both a strong and query_eval LLM. After finding the appropriate documents using embeddings, the query_eval LLM is used to filter through the documents that don't seem to be about the question, then the strong LLM answers the question based on each remaining documents, then combines them all in a neat markdown. Also `wdoc` is very customizable.
  * **Why can `wdoc` also produce summaries?**
      * I have little free time so I needed a tailor made summary feature to keep up with the news. But most summary systems are rubbish and just try to give you the high level takeaway points, and don't handle properly text chunking. So I made my own tailor made summarizer. **The summary prompts can be found in `utils/prompts.py` and focus on extracting the arguments/reasonning/though process/arguments of the author then use markdown indented bullet points to make it easy to read.** It's really good! The prompts dataclass is not frozen so you can provide your own prompt if you want.
  * **What other tasks are supported by `wdoc`?**
      * See [Supported tasks](#Supported-tasks).
  * **Which LLM providers are supported by `wdoc`?**
      * `wdoc` supports virtually any LLM provider thanks to [litellm](https://docs.litellm.ai/). It even supports local LLM and local embeddings (see [Walkthrough and examples](#Walkthrough-and-examples) section).
  * **What do you use `wdoc` for?**
      * I follow heterogeneous sources to keep up with the news: youtube, website, etc. So thanks to `wdoc` I can automatically create awesome markdown summaries that end up straight into my [Logseq](https://github.com/logseq/logseq/) database as a bunch of `TODO` blocks.
      * I use it to ask technical questions to my vast heterogeneous corpus of medical knowledge.
      * I use it to query my personal documents using the `--private` argument.
      * I sometimes use it to summarize a documents then go straight to asking questions about it, all in the same command.
      * I use it to ask questions about entire youtube playlists.
      * Other use case are the reason I made the [scripts made with `wdoc` section](#scripts-made-with-wdoc)
  * **What's up with the name?**
      * One of my favorite character (and somewhat of a rolemodel is [Winston Wolf](https://www.youtube.com/watch?v=UeoMuK536C8) and after much hesitation I decided `WolfDoc` would be too confusing and `WinstonDoc` sounds like something micro$oft would do. Also `wd` and `wdoc` were free, whereas `doctools` was already taken. The initial name of the project was `DocToolsLLM`, a play on words between 'doctor' and 'tool'.
  * **How can I improve the prompt for a specific task without coding?**
      * Each prompt of the `query` task are roleplaying as employees working for WDOC-CORP©, either as `Eve the Evaluator` (the LLM that filters out relevant documents), `Anna the Answerer` (the LLM that answers the question from a filtered document) or `Carl the Combiner` (the LLM that combines answers from Answerer as one). There's also `Sam the Summarizer` for summaries and `Raphael the Rephraser` to expand your query. They are all receiving orders from you if you talk to them in a prompt.
  * **How can I use `wdoc`'s parser for my own documents?**
      * If you are in the shell cli you can easily use `wdoc parse my_file.pdf` (this actually replaces the call to call instead `wdoc_parse_file my_file.pdf`).
      add `--only_text` to only get the text and no metadata. If you're having problem with argument parsing you can try adding the `--pipe` argument.
      * If you want the document using python:
          ``` python
          from wdoc import wdoc
          list_of_docs = Wdoc.parse_file(path=my_path)
          ```
      * Another example would be to use wdoc to parse an anki deck: `wdoc_parse_file --filetype "anki" --anki_profile "Main" --anki_deck "mydeck::subdeck1" --anki_notetype "my_notetype" --anki_template "<header>\n{header}\n</header>\n<body>\n{body}\n</body>\n<personal_notes>\n{more}\n</personal_notes>\n<tags>{tags}</tags>\n{image_ocr_alt}" --anki_tag_filter "a::tag::regex::.*something.*" --only_text`
  * **What should I do if my PDF are encrypted?**
      * If you're on linux you can try running `qpdf --decrypt input.pdf output.pdf`
          * I made a quick and dirty batch script for [in this repo](https://github.com/thiswillbeyourgithub/PDF_batch_decryptor)
  * **How can I add my own pdf parser?**
      * Write a python class and add it there: `wdoc.utils.loaders.pdf_loaders['parser_name']=parser_object` then call `wdoc` with `--pdf_parsers=parser_name`.
          * The class has to take a `path` argument in `__init__`, have a `load` method taking
          no argument but returning a `List[Document]`. Take a look at the `OpenparseDocumentParser`
          class for an example.

  * **What should I do if I keep hitting rate limits?**
      * The simplest way is to add the `debug` argument. It will disable multithreading,
          multiprocessing and LLM concurrency. A less harsh alternative is to set the
          environment variable `WDOC_LLM_MAX_CONCURRENCY` to a lower value.

  * **How can I run the tests?**
      * Try `python -m pytest tests/test_wdoc.py -v -m basic` to run the basic tests, and `python -m pytest tests/test_wdoc.py -v -m api` to run the test that use external APIs.

  * **How can I query a text but without chunking? / How can I query a text with the full text as context?**
      * If you set the environment variable `WDOC_MAX_CHUNK_SIZE` to a very high value and use a model with enough context according to litellm's metadata, then no chunking will happen and the LLM will have the full text as context.

  </details>


pkgId: 5a9b881f39311c408bf6129fbe2a10a19837c422695fb4db2ae757af863532e0
name: python-weather-query-xiaomei-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for weather-query-xiaomei
url: https://pypi.org/project/weather-query-xiaomei/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-weather-query-xiaomei-0.1.0-1.src.rpm
location_href: Packages/python-weather-query-xiaomei-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  query weather of different city for mt users





  The server implements a simple note storage system with:
  - Custom note:// URI scheme for accessing individual notes
  - Each note resource has a name, description and text/plain mimetype



  The server provides a single prompt:
  - summarize-notes: Creates summaries of all stored notes
    - Optional "style" argument to control detail level (brief/detailed)
    - Generates prompt combining all current notes with style preference



  The server implements one tool:
  - add-note: Adds a new note to the server
    - Takes "name" and "content" as required string arguments
    - Updates server state and notifies clients of resource changes



  [TODO: Add configuration details specific to your implementation]







  On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
  On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

  <details>
    <summary>Development/Unpublished Servers Configuration</summary>
    ```
    "mcpServers": {
      "weather_query_xiaomei": {
        "command": "uv",
        "args": [
          "--directory",
          "/Users/shelmin/PycharmProjects/xiaomei-mcp-server/weather_query_xiaomei",
          "run",
          "weather_query_xiaomei"
        ]
      }
    }
    ```
  </details>

  <details>
    <summary>Published Servers Configuration</summary>
    ```
    "mcpServers": {
      "weather_query_xiaomei": {
        "command": "uvx",
        "args": [
          "weather_query_xiaomei"
        ]
      }
    }
    ```
  </details>





  To prepare the package for distribution:

  1. Sync dependencies and update lockfile:
  ```bash
  uv sync
  ```

  2. Build package distributions:
  ```bash
  uv build
  ```

  This will create source and wheel distributions in the `dist/` directory.

  3. Publish to PyPI:
  ```bash
  uv publish
  ```

  Note: You'll need to set PyPI credentials via environment variables or command flags:
  - Token: `--token` or `UV_PUBLISH_TOKEN`
  - Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`



  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 /Users/shelmin/PycharmProjects/xiaomei-mcp-server/weather_query_xiaomei run weather-query-xiaomei
  ```


  Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.


pkgId: 12285ece5bd65bb0e16e9f8e2139a3c65d339cd653504cd71df91f59d5e87941
name: python-weatherDB-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for weatherDB
url: https://gitlab.uni-freiburg.de/hydrology/weatherDB/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-weatherDB-1.0.6-1.src.rpm
location_href: Packages/python-weatherDB-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  Author: [Max Schmit](https://github.com/maxschmi)

  [![Documentation Status](https://readthedocs.org/projects/weatherdb/badge/?version=latest)](https://weatherdb.readthedocs.io/latest)
  [![Pipeline status](https://gitlab.uni-freiburg.de/hydrology/weatherDB/badges/master/pipeline.svg?ignore_skipped=true)](https://gitlab.uni-freiburg.de/hydrology/weatherDB/-/pipelines)

  The weather-DB module offers an API to interact with the automatically filled weather Database.

  Depending on the Database user privileges you can use more or less methods of the classes.

  There are 3 different sub modules with their corresponding classes.

  - station:
  Has a class for every type of station. E.g. PrecipitationStation (or StationP).
  One object represents one Station with one parameter.
  This object can get used to get the corresponding timeserie.
  There is also a GroupStation class that groups the three parameters precipitation, temperature and evapotranspiration together for one station. If one parameter is not available this one won't get grouped.
  - stations:
  Is a grouping class for all the stations of one measurement parameter. E.G. PrecipitationStations (or StationsP).
  Can get used to do actions on all the stations.
  - broker:
  This submodule has only one class Broker. This one is used to do actions on all the stations together. Mainly only used for updating the Database.



  To install the package use PIP to install the Github repository:

  ```cmd
  pip install weatherDB
  ```

  If you also want to install the optional dependencies use:

  ```batch
  pip install weatherDB[optionals]
  ```

  Or to upgrade use:

  ```cmd
  pip install weatherDB --upgrade
  ```



  To start using this package you first need to setup the database. For further information please have a look at the [documentation](https://weatherdb.readthedocs.io/latest/) for a detailed [Configuration Guide](https://weatherdb.readthedocs.io/latest/setup/Configuration.html)

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


pkgId: b0919e125157c15d455ed12dd7c7a63c991357443c0f450901757b2dbaf2dfe1
name: python-weave-help
arch: noarch
version: 0.51.25
epoch: 0
release: 1
summary: Development documents and examples for weave
url: https://pypi.org/project/weave/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-weave-0.51.25-1.src.rpm
location_href: Packages/python-weave-help-0.51.25-1.noarch.rpm
checksum_type: sha256
description:
  You can use Weave to:
  - Log and debug language model inputs, outputs, and traces
  - Build rigorous, apples-to-apples evaluations for language model use cases
  - Organize all the information generated across the LLM workflow, from experimentation to evaluations to production
  Our goal is to bring rigor, best-practices, and composability to the inherently experimental process of developing Generative AI software, without introducing cognitive overhead.
  <div align="center">
    <img src="https://raw.githubusercontent.com/wandb/weave/master/docs/static/weave-ui-example.jpg" width="100%">
  </div>

  Our documentation site can be found [here](https://wandb.me/weave)

  ```
  pip install weave
  ```


  You can trace any function using `weave.op()` - from api calls to OpenAI, Anthropic, Google AI Studio etc to generation calls from Hugging Face and other open source models to any other validation functions or data transformations in your code you'd like to keep track of.
  Decorate all the functions you want to trace, this will generate a trace tree of the inputs and outputs of all your functions:
  ```python
  import weave
  weave.init("weave-example")
  @weave.op()
  def sum_nine(value_one: int):
      return value_one + 9
  @weave.op()
  def multiply_two(value_two: int):
      return value_two * 2
  @weave.op()
  def main():
      output = sum_nine(3)
      final_output = multiply_two(output)
      return final_output
  main()
  ```

  ```python
  import weave
  import json
  from openai import OpenAI
  @weave.op()
  def extract_fruit(sentence: str) -> dict:
      client = OpenAI()
      response = client.chat.completions.create(
      model="gpt-3.5-turbo-1106",
      messages=[
          {
              "role": "system",
              "content": "You will be provided with unstructured data, and your task is to parse it one JSON dictionary with fruit, color and flavor as keys."
          },
          {
              "role": "user",
              "content": sentence
          }
          ],
          temperature=0.7,
          response_format={ "type": "json_object" }
      )
      extracted = response.choices[0].message.content
      return json.loads(extracted)
  weave.init('intro-example')
  sentence = "There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy."
  extract_fruit(sentence)
  ```

  Interested in pulling back the hood or contributing? Awesome, before you dive in, here's what you need to know.
  We're in the process of 🧹 cleaning up 🧹. This codebase contains a large amount code for the "Weave engine" and "Weave boards", which we've put on pause as we focus on Tracing and Evaluations.
  The Weave Tracing code is mostly in: `weave/trace` and `weave/trace_server`.
  The Weave Evaluations code is mostly in `weave/flow`.

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


pkgId: 803ff37d62fb3f364df25a916ad859882c62716caf20bbd67378f1a6f285c92b
name: python-weaviate-client-help
arch: noarch
version: 4.10.2
epoch: 0
release: 1
summary: Development documents and examples for weaviate-client
url: https://github.com/weaviate/weaviate-python-client
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-weaviate-client-4.10.2-1.src.rpm
location_href: Packages/python-weaviate-client-help-4.10.2-1.noarch.rpm
checksum_type: sha256
description:
  A python native client for easy interaction with a Weaviate instance.
  The client is tested for python 3.9 and higher.
  Visit the official `Weaviate <https://weaviate.io/>`_ website for more information about the Weaviate and how to use it in production.


pkgId: a03424dd8e631db1b87c8ba7d571471d713e991c4bff8ac92bf178bc0bd04f65
name: python-web3-ethereum-defi-help
arch: noarch
version: 0.27
epoch: 0
release: 1
summary: Development documents and examples for web3-ethereum-defi
url: https://web3-ethereum-defi.readthedocs.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-web3-ethereum-defi-0.27-1.src.rpm
location_href: Packages/python-web3-ethereum-defi-help-0.27-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/web3-ethereum-defi.svg)](https://badge.fury.io/py/web3-ethereum-defi)

  [![Automated test suite](https://github.com/tradingstrategy-ai/web3-ethereum-defi/actions/workflows/test.yml/badge.svg)](https://github.com/tradingstrategy-ai/web3-ethereum-defi/actions/workflows/test.yml)

  [![Documentation Status](https://readthedocs.org/projects/web3-ethereum-defi/badge/?version=latest)](https://web3-ethereum-defi.readthedocs.io/)



  Web-Ethereum-DeFi (`eth_defi`) Python package provides high level modules for smart
  contracts, with prepackaged ABI files for DeFi protocol integration,
  wallet management, JSON-RPC providers and automated test suites. The
  package aims for robustness, high quality of the code and documentation.

  * [Use cases](#use-cases)
  * [Prerequisites](#prerequisites)
  * [Install](#install)
  * [Code examples](#code-examples)
     * [Deploy and transfer ERC-20 token between wallets](#deploy-and-transfer-erc-20-token-between-wallets)
     * [Uniswap v2 trade example](#uniswap-v2-trade-example)
     * [Uniswap v2 price estimation example](#uniswap-v2-price-estimation-example)
  * [How to use the library in your Python project](#how-to-use-the-library-in-your-python-project)
  * [Documentation](#documentation)
    * [Development and contributing](#development-and-contributing)
  * [Version history](#version-history)
  * [Support](#support)
  * [Social media](#social-media)
  * [History](#history)
  * [License](#license)

  ![Supported protocols include Uniswap, Aave, others](./docs/source/logo-wall-white.png)

  -   Supported [blockchains](https://tradingstrategy.ai/glossary) include
      Ethereum, BNB Chain, Polygon, Avalanche C-chain, Arbitrum and many
      other [EVM-compatible
      blockchains](https://tradingstrategy.ai/glossary/evm-compatible).
  -   Supported
      [DeFi](https://tradingstrategy.ai/glossary/decentralised-finance)
      [protocols](https://tradingstrategy.ai/glossary/protocol) include
      [Uniswap](https://tradingstrategy.ai/glossary/uniswap) with its
      [clones](https://tradingstrategy.ai/glossary/fork),
      [Aave](https://tradingstrategy.ai/glossary/aave),
      [USDC](https://tradingstrategy.ai/glossary/usdc), other Circle
      [stablecoin tokens](https://tradingstrategy.ai/glossary/stablecoin),
      [Enzyme](https://tradingstrategy.ai/glossary/enzyme-protocol),
      Chainlink and many others.



  Use cases for this package include

  -   Trading and bots
  -   Data research, extraction, transformation and loading
  -   Portfolio management and accounting
  -   System integrations and backends



  Features include e.g.

  * [High-quality API documentation](https://web3-ethereum-defi.readthedocs.io/)
  * [Fully type hinted](https://web3-ethereum-defi.readthedocs.io/) for good developer experience
  * [MEV protection](https://web3-ethereum-defi.readthedocs.io/api/provider/_autosummary_provider/eth_defi.provider.mev_blocker.html#module-eth_defi.provider.mev_blocker)
  * [Mainnet forking with Anvil](https://web3-ethereum-defi.readthedocs.io/api/_autosummary/eth_defi.anvil.html#module-eth_defi.anvil)
  * [Revert reasons and stack traces for Solidity errors](https://web3-ethereum-defi.readthedocs.io/api/_autosummary/eth_defi.trace.html)
  * [Swap, slippage and price impact estimation](https://web3-ethereum-defi.readthedocs.io/api/index.html)
  * [ERC-20 token issuance and transfers](https://web3-ethereum-defi.readthedocs.io/en/latest/_autosummary/eth_defi.token.html#module-eth_defi.token)
  * [EIP-712, EIP-3009 support](https://web3-ethereum-defi.readthedocs.io/api/core/_autosummary/eth_defi.eip_712.html#module-eth_defi.eip_712)

  Web3-Ethereum-Defi supports

  * Uniswap (both v2 and v3)
  * Sushi
  * Aave
  * Enzyme Protocol
  * dHEDGE Protocol
  * More integrations to come
  * Built-in integration for over 600 smart contracts with precompiled Solidity ABI files

  [Read the full API documentation](https://web3-ethereum-defi.readthedocs.io/)).
  For code examples please see below.



  To use this package you need to

  * Have Python 3.10, Python 3.11, or Python 3.12 (no other versions tested)
  * macOS, Linux or Windows Subsystem for Linux (WSL) needed, Microsoft Windows is not officially supported
  * [Be proficient in Python programming](https://wiki.python.org/moin/BeginnersGuide)
  * [Understand of Web3.py library](https://web3py.readthedocs.io/en/stable/)
  * [Understand Pytest basics](https://docs.pytest.org/)



  With `pip`:

  ```shell
  pip install "web3-ethereum-defi[data]"
  ```

  With `poetry`:

  ```shell

  poetry add -E data web3-ethereum-defi
  ```

  With `poetry` - master Git branch:

  ```shell
  git clone git@github.com:tradingstrategy-ai/web3-ethereum-defi.git
  cd web3-ethereum-defi
  poetry shell
  poetry install --all-extras
  ```



  See [the tutorials section in the documentation](https://web3-ethereum-defi.readthedocs.io/tutorials/index.html)
  for full code examples.



  - This example shows how to read the live trades of PancakeSwap,
    and other [Uniswap v2 compatible forks](https://tradingstrategy.ai/glossary/fork) on BNB Smart Chain

  - [See the instructions and full example source code in Tutorials](https://web3-ethereum-defi.readthedocs.io/tutorials/pancakeswap-live-minimal.html)

  ```python
  import os
  import time
  from functools import lru_cache

  from web3 import HTTPProvider, Web3

  from eth_defi.abi import get_contract
  from eth_defi.chain import install_chain_middleware
  from eth_defi.event_reader.filter import Filter
  from eth_defi.event_reader.logresult import decode_log
  from eth_defi.event_reader.reader import read_events, LogResult
  from eth_defi.uniswap_v2.pair import fetch_pair_details, PairDetails


  QUOTE_TOKENS = ["BUSD", "USDC", "USDT"]


  @lru_cache(maxsize=100)
  def fetch_pair_details_cached(web3: Web3, pair_address: str) -> PairDetails:
      return fetch_pair_details(web3, pair_address)


  def main():
      json_rpc_url = os.environ.get("JSON_RPC_BINANCE", "https://bsc-dataseed.binance.org/")
      web3 = Web3(HTTPProvider(json_rpc_url))
      web3.middleware_onion.clear()
      install_chain_middleware(web3)

      
      
      
      
      
      Pair = get_contract(web3, "sushi/UniswapV2Pair.json")

      filter = Filter.create_filter(address=None, event_types=[Pair.events.Swap])

      latest_block = web3.eth.block_number

      
      while True:

          start = latest_block
          end = web3.eth.block_number

          evt: LogResult
          for evt in read_events(
              web3,
              start_block=start,
              end_block=end,
              filter=filter,
          ):

              decoded = decode_log(evt)

              
              pair = fetch_pair_details_cached(web3, decoded["address"])
              token0 = pair.token0
              token1 = pair.token1
              block_number = evt["blockNumber"]

              
              if token0.symbol in QUOTE_TOKENS:
                  base = token1  # token
                  quote = token0  # stablecoin/BNB
                  base_amount = decoded["args"]["amount1Out"] - decoded["args"]["amount1In"]
                  quote_amount = decoded["args"]["amount0Out"] - decoded["args"]["amount0In"]
              else:
                  base = token0  # stablecoin/BNB
                  quote = token1  # token
                  base_amount = decoded["args"]["amount0Out"] - decoded["args"]["amount0Out"]
                  quote_amount = decoded["args"]["amount1Out"] - decoded["args"]["amount1Out"]

              
              if base_amount and quote_amount:
                  human_base_amount = base.convert_to_decimals(base_amount)
                  human_quote_amount = quote.convert_to_decimals(quote_amount)
                  price = human_quote_amount / human_base_amount

                  if human_quote_amount > 0:
                      
                      
                      direction = "sell"
                  else:
                      direction = "buy"

                  price = abs(price)

                  print(f"Swap block:{block_number:,} tx:{evt['transactionHash']} {direction} price:{price:,.8f} {base.symbol}/{quote.symbol}")
              else:
                  
                  
                  pass

          else:
              
              print(".")

          latest_block = end
          time.sleep(1)


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



  Add `web3-ethereum-defi` as a development dependency:

  Using [Poetry](https://python-poetry.org/):

  ```shell

  poetry add -D "web3-ethereum-defi[data]"
  ```



  - [Browse API documentation](https://web3-ethereum-defi.readthedocs.io/).
  - [Browse tutorials](https://web3-ethereum-defi.readthedocs.io/tutorials/index.html).



  - [Read development instructions](https://web3-ethereum-defi.readthedocs.io/development.html).



  - [Read changelog](https://github.com/tradingstrategy-ai/web3-ethereum-defi/blob/master/CHANGELOG.md).
  - [See releases](https://pypi.org/project/web3-ethereum-defi/#history).



  - [Join Discord for any questions](https://tradingstrategy.ai/community).



  - [Watch tutorials on YouTube](https://www.youtube.com/@tradingstrategyprotocol)
  - [Follow on Twitter](https://twitter.com/TradingProtocol)
  - [Follow on Telegram](https://t.me/trading_protocol)
  - [Follow on LinkedIn](https://www.linkedin.com/company/trading-strategy/)



  MIT.

  [Created by Trading Strategy](https://tradingstrategy.ai).


pkgId: ab805ccfa061424be85ee0fb7ff23ca9467a61b4512839de5aac857dbee95e9e
name: python-web3-help
arch: noarch
version: 7.6.1
epoch: 0
release: 1
summary: Development documents and examples for web3
url: https://github.com/ethereum/web3.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-web3-7.6.1-1.src.rpm
location_href: Packages/python-web3-help-7.6.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Join the conversation on Discord](https://img.shields.io/discord/809793915578089484?color=blue&label=chat&logo=discord&logoColor=white)](https://discord.gg/GHryRvPB84)
  [![Build Status](https://circleci.com/gh/ethereum/web3.py.svg?style=shield)](https://circleci.com/gh/ethereum/web3.py)
  [![PyPI version](https://badge.fury.io/py/web3.svg)](https://badge.fury.io/py/web3)
  [![Python versions](https://img.shields.io/pypi/pyversions/web3.svg)](https://pypi.python.org/pypi/web3)
  [![Docs build](https://readthedocs.org/projects/web3py/badge/?version=latest)](https://web3py.readthedocs.io/en/latest/?badge=latest)



  web3.py allows you to interact with the Ethereum blockchain using Python, enabling you to build decentralized applications, interact with smart contracts, and much more.

  - Python 3.8+ support

  ______________________________________________________________________



  [Get started in 5 minutes](https://web3py.readthedocs.io/en/latest/quickstart.html) or
  [take a tour](https://web3py.readthedocs.io/en/latest/overview.html) of the library.



  For additional guides, examples, and APIs, see the [documentation](https://web3py.readthedocs.io/en/latest/).



  Want to file a bug, contribute some code, or improve documentation? Excellent! Read up on our
  guidelines for [contributing](https://web3py.readthedocs.io/en/latest/contributing.html),
  then check out issues that are labeled
  [Good First Issue](https://github.com/ethereum/web3.py/issues?q=is%3Aissue+is%3Aopen+label%3A%22Good+First+Issue%22).

  ______________________________________________________________________



  Join the conversation in the Ethereum Python Community [Discord](https://discord.gg/GHryRvPB84).


pkgId: 8a4eedc460b3cbcc026a717bb4d325fbd5112223cb9aa38c6e7ac04e88bf9af7
name: python-weba-help
arch: noarch
version: 0.2.4
epoch: 0
release: 1
summary: Development documents and examples for weba
url: https://cj.github.io/weba/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-weba-0.2.4-1.src.rpm
location_href: Packages/python-weba-help-0.2.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Release](https://img.shields.io/github/v/release/cj/weba)](https://img.shields.io/github/v/release/cj/weba)
  [![Build status](https://img.shields.io/github/actions/workflow/status/cj/weba/main.yml?branch=main)](https://github.com/cj/weba/actions/workflows/main.yml?query=branch%3Amain)
  [![codecov](https://codecov.io/gh/cj/weba/branch/main/graph/badge.svg)](https://codecov.io/gh/cj/weba)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/cj/weba)](https://img.shields.io/github/commit-activity/m/cj/weba)
  [![License](https://img.shields.io/github/license/cj/weba)](https://img.shields.io/github/license/cj/weba)

  Weba is a Python library for building web user interfaces using a declarative,
  component-based approach. It provides a clean API for creating HTML elements and
  components with proper context management and type safety. The library extends
  BeautifulSoup's functionality by adding a custom Tag class that supports modern web
  development patterns, including HTMX integration, class list manipulation, and
  comment-based selectors. It allows developers to create reusable UI components with
  proper isolation, supports both synchronous and asynchronous contexts, and handles
  attribute management (including JSON serialization) elegantly. The library emphasizes
  type safety and follows clean code practices, making it particularly suitable for
  building modern web applications in Python with a focus on maintainability and developer
  experience.

  - **Github repository**: <https://github.com/cj/weba/>
  - **Documentation** <https://weba.cj.io/>


pkgId: 83ecbc3cc815fc57d2cf8b9d25d49669b9d82f4cfaec92b63a5a55748a1cde4c
name: python-webarticlecurator-help
arch: noarch
version: 1.12.0
epoch: 0
release: 1
summary: Development documents and examples for webarticlecurator
url: https://github.com/ELTE-DH/WebArticleCurator
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webarticlecurator-1.12.0-1.src.rpm
location_href: Packages/python-webarticlecurator-help-1.12.0-1.noarch.rpm
checksum_type: sha256
description:
  A crawler program which can be used for downloading the content of portals (news, forums, blogs) and converting it to the desired output format, in accordance with the configuration.



  - Python 3.8+
  - (optional for corpus converter if installed as `webarticlecurator[newspaper3k]`) for Newspaper3k, the installation of the following packages must precede the installation of this program: python3-dev libxml2-dev libxslt-dev libjpeg-dev zlib1g-dev libpng12-dev





  `pip3 install webarticlecurator`

  The following extras can be installed:

  - Newspaper3k: `newspaper`
  - All the above: `full`

  E.g. `pip3 install webarticlecurator[full]`



  [_Poetry_](https://python-poetry.org/) and (optionally) [_GNU Make_](https://www.gnu.org/software/make/) are required.

  1. `git clone https://github.com/ELTE-DH/webarticlecurator.git`
  2. Run `make`

  On Windows or without Make (after cloning the repository):

  1. `poetry install --no-root`
  2. `poetry build`
  3. `poetry run pip install --upgrade dist/*.whl` (the correct filename must be specified on Windows)

  To install extras run: `poetry install -E [NAME OF THE EXTRA TO INSTALL]`



  The program can be used in multiple ways:

  - Crawling (see the options below): `python3 -m webarticlecurator crawl CONFIGURATION [parameters]`
  - Listing URLs in a previously created WARC file: `python3 -m webarticlecurator listurls -s SOURCE_WARC`
  - Validating a previously created WARC file (with [warcio](https://github.com/webrecorder/warcio)): `python3 -m webarticlecurator validate -s SOURCE_WARC`
  - Sampling a previously created WARC file based on a list of URLs (one URL per line, URLs not present in the source archive are downloaded if `--offline` is False. If `--negative` is specified all URLs are sampled except ones from the list): `python3 -m webarticlecurator sample -s SOURCE_WARC -i selected_urls.txt TARGET_WARC --offline True/False --negative True/False`
  - Printing the content of the selected URLs into an empty directory: `python3 -m webarticlecurator cat -s SOURCE_WARC -i selected_urls.txt TARGET_DIR`
  - Downloading a single URL (for testing purposes): `python3 -m webarticlecurator download SOURCE_URL TARGET_WARC`
  - Check URLs in the extracted article urls of an archive warc (for debugging a portal): `python3 -m webarticlecurator checkurls -s SOURCE_WARC -i selected_urls.txt -d TARGET_DIR CONFIGURATION`
  - As a library: Check [strategies.py](src/webarticlecurator/strategies.py) and [enhanced_downloader.py](src/webarticlecurator/enhanced_downloader.py) for details !



  The configuration is divided into three levels. On the first two levels, YAML is used for the configuration format with schema checks.
  The third level of configuration uses Python functions.



  It specifies the configuration for the current crawling process with the following fields:

  - `schema`: The filename pointing to the schema of the portal to be crawled (second level configuration)
  - `output_corpus` (optional): The desired filename of the output corpus (default: no output corpus)
  - `log_file_archive` (optional): The log file for the archive crawler (default: log is not saved)
  - `log_file_articles` (optional): The log file for the article crawler (default: log is no saved)
  - `new_problematic_archive_urls` (optional): The file where the problematic archive URLs should be written (default: URLs are not saved)
  - `new_problematic_urls` (optional): The file where the problematic article URLs should be written (default: URLs are not saved)
  - `new_good_archive_urls` (optional): The file where the newly downloaded, good archive URLs should be written (default: URLs are not saved)
  - `new_good_urls` (optional): The file where the newly downloaded, good article URLs should be written (default: URLs are not saved)
  - `date_from` (optional): The inclusive minimal date of the required articles in ISO 8601 format, YYYY-MM-DD (default: from the schema of the portal if applies)
  - `date_until` (optional): The inclusive maximal date of the required articles in ISO 8601 format, YYYY-MM-DD (default: yesterday if applies)



  The following parameters must be filled in the case of every portal:

  - `site_name`: A friendly name for the portal
  - `new_article_url_threshold`: The minimal amount of new URLs required on an archive page (e.g. the archive pages slid due to new articles in case of an active portal)

  Python functions:

  - `portal_specific_exctractor_functions_file`: The filename pointing to the python file which contains the required extractor functions
  - `extract_next_page_url_fun` (it can be NULL): The name of the function to be imported from the `portal_specific_exctractor_functions_file` to extract the "next page URL"
  - `extract_article_urls_from_page_fun`: The name of the function to be imported from the `portal_specific_exctractor_functions_file` to extract the article URLs from the archive page
  - `extract_article_urls_from_page_plus_fun`: The name of the function to be imported from the `portal_specific_exctractor_functions_file` to extract the article URLs from the archive page with metadata form the portal's archive (for `checkurls` mode)
  - `next_page_of_article_fun` (it can be NULL): The name of the function to be imported from the `portal_specific_exctractor_functions_file` if there are multipage articles. This function extracts the "next page URL" for the rest of the pages in a multipage article. (It must be used with `MultiPageArticleConverter` or similar as `corpus_converter` to work!)
  - `corpus_converter_file`: The filename pointing to the python file which contains the required corpus extractor class
  - `corpus_converter`: The name of the class to be imported from the `corpus_converter_file`. The default is to do nothing (`dummy-converter`).

  Boolean features to describe the site:

  - `next_url_by_pagenum`: Use page numbering for pagination of the archive, e.g. infinite scrolling (false means no pages or pages handled by `extract_next_page_url_fun`)
  - `infinite_scrolling`: The crawler increment page numbers until the first page with zero article urls
  - `archive_page_urls_by_date`: Group the archive page URLs by their dates
  - `go_reverse_in_archive`: Go reverse (backwards in time) in the archive by date (when the earliest article is not known)
  - `verify_request`: Suppress complaining about invalid HTTPS certificates
  - `ignore_archive_cache`: Ignore archive cache (for those portals which only use pagination)
  - `stop_on_empty_archive_page` (optional): Stop archive crawling if no articles extracted from page (default: false)
  - `stop_on_taboo_set` (optional): Stop archive crawling when one or more URLs in `taboo_article_urls` list is specified (default: false)

  Column definitions:

  In the `columns` dictionary, the following features can be set for each column (defined with a friendly name):

  - `date_first_article` (optional): The date of the first article on the portal/column (also used for archive crawling)
  - `date_first_article` (optional): The date of the last article on the portal/column (also used for archive crawling)
  - `initial_pagenum` (optional): The initial page number which could be omitted (an empty string if not set, else it should be `min_pagenum` - 1)
  - `min_pagenum` (optional): The "first" page number to increment (e.g. initial_pagenum + 1 = min_pagenum <= max_pagenum if not a single page column where only initial_pagenum must be specified, min_pagenum and max_pagenum must be omitted)
  - `max_pagenum` (optional): The upper bound of the number of pages for safety or for stop criteria
  - `archive_url_format`: The schema for the archive URL of the portal/column (supply `#year`, `#month`, `#day` and
   `#next-year`, `#next-month`, `#next-day` tags which have to be replaced with the actual field of date, and
   `#pagenum` with the actual page number during the crawling)
  - `max_tries` (optional): How many times should we try to download an archive URL? (defautlt: 1)

  Note: One can iterate the archive by months or years by omitting `#day` (`#next-day`) or `#month` (`#next-month`)



  There are maximum three types of extractors to be included for each portal.
  See the examples in the `configs` directory for further information and `DummyConverter` for the converter API.



  The first two command-line parameters should be `crawl` and the filename pointing to the configuration file of the current crawl. These can be followed by some optional parameters:

  - `--old-archive-warc OLD_ARCHIVE_WARC`: Existing WARC archives of the portal's archive (use them as cache)
  - `--archive-warc ARCHIVE_WARC`: New WARC archive of the portal's archive (copy all cached pages if `--old-archive-warc` is specified)
  - `--old-articles-warc OLD_ARTICLES_WARC`: Existing WARC archives of the portal's archive (use them as cache)
  - `--articles-warc ARTICLES_WARC`: New WARC archive of the portal's archive (copy all cached pages if `--old-archive-warc` is specified)
  - `--archive-just-cache [ARCHIVE_JUST_CACHE]`: Use only cached pages (no output WARC file): `--old-archive-warc` must be specified!
  - `--articles-just-cache [ARTICLES_JUST_CACHE]`: Use only cached pages (no output WARC file): `--old-articles-warc` must be specified!
  - `--debug-news-archive [DEBUG_NEWS_ARCHIVE]`: Set DEBUG logging on NewsArchiveCrawler and print the number of extracted URLs per page
  - `--strict [STRICT]`: Set strict-mode in WARCReader to enable validation
  - `--crawler-name CRAWLER_NAME`: The name of the crawler for the WARC info record
  - `--user-agent USER_AGENT`: The User-Agent string to use in headers while downloading
  - `--no-overwrite-warc`: Do not overwrite `--{archive,articles}-warc` if needed
  - `--cumulative-error-threshold CUMULATIVE_ERROR_THRESHOLD`: The sum of download errors before giving up
  - `--known-bad-urls KNOWN_BAD_URLS`: Known bad URLs to be excluded from download (filename, one URL per line)
  - `--known-article-urls KNOWN_ARTICLE_URLS`: Known article URLs to mark the desired end of the archive (filename, one URL per line)
  - `--max-no-of-calls-in-period MAX_NO_OF_CALLS_IN_PERIOD`: Limit the number of HTTP requests per period
  - `--limit-period LIMIT_PERIOD`: Limit the period of HTTP requests (in seconds), see also `--max-no-of-calls-in-period`
  - `--proxy-url PROXY_URL`: SOCKS Proxy URL to use, e.g. socks5h://localhost:9050
  - `--allow-cookies [ALLOW_COOKIES]`: Allow session cookies
  - `--stay-offline [STAY_OFFLINE]`: Do not download but write output WARC (see `--just-cache` when no output WARC file is needed)
  - `--archive`: Crawl only the portal's archive
  - `--articles`: Crawl articles (and optionally use cached WARC for the portal's archive), DEFAULT behaviour
  - `--corpus`: Use `--old-articles-warc` to create a corpus (no crawling, equals to `--archive-just-cache` and `--articles-just-cache`)



  This project is licensed under the terms of the GNU LGPL 3.0 license.



  This software is the direct continuation of [corpusbuilder](https://github.com/ppke-nlpg/corpusbuilder).
  The authors gratefully acknowledge the groundbreaking work of all pioneers who inspired this program.
  Special thanks go to Tibor Kákonyi who put the initial implementation under the GNU LGPL 3.0 license and allowing us to continue his work.



  The DOI of the code is: https://doi.org/10.5281/zenodo.3755323

  If you use this program, please cite the following paper:

  [__The ELTE.DH Pilot Corpus – Creating a Handcrafted Gigaword Web Corpus with Metadata__ Balázs Indig, Árpád Knap, Zsófia Sárközi-Lindner, Mária Timári, Gábor Palkó _In the Proceedings of the 12th Web as Corpus Workshop (WAC XII)_, pages 33-41 Marseille, France 2020](https://www.aclweb.org/anthology/2020.wac-1.5.pdf)

  ```
  @inproceedings{indig-etal-2020-elte,
      title = "The {ELTE}.{DH} Pilot Corpus {--} Creating a Handcrafted {G}igaword Web Corpus with Metadata",
      author = {Indig, Bal{\'a}zs  and
        Knap, {\'A}rp{\'a}d  and
        S{\'a}rk{\"o}zi-Lindner, Zs{\'o}fia  and
        Tim{\'a}ri, M{\'a}ria  and
        Palk{\'o}, G{\'a}bor},
      booktitle = "Proceedings of the 12th Web as Corpus Workshop",
      month = may,
      year = "2020",
      address = "Marseille, France",
      publisher = "European Language Resources Association",
      url = "https://www.aclweb.org/anthology/2020.wac-1.5",
      pages = "33--41",
      abstract = "In this article, we present the method we used to create a middle-sized corpus using targeted web crawling. Our corpus contains news portal articles along with their metadata, that can be useful for diverse audiences, ranging from digital humanists to NLP users. The method presented in this paper applies rule-based components that allow the curation of the text and the metadata content. The curated data can thereon serve as a reference for various tasks and measurements. We designed our workflow to encourage modification and customisation. Our concept can also be applied to other genres of portals by using the discovered patterns in the architecture of the portals. We found that for a systematic creation or extension of a similar corpus, our method provides superior accuracy and ease of use compared to The Wayback Machine, while requiring minimal manpower and computational resources. Reproducing the corpus is possible if changes are introduced to the text-extraction process. The standard TEI format and Schema.org encoded metadata is used for the output format, but we stress that placing the corpus in a digital repository system is recommended in order to be able to define semantic relations between the segments and to add rich annotation.",
      language = "English",
      ISBN = "979-10-95546-68-9",
  }
  ```


pkgId: 4725436ea5d3da72fef75ce17c5180b6fe970a04354cb545a8bd2cd1479742bd
name: python-webcap-help
arch: noarch
version: 0.1.10
epoch: 0
release: 1
summary: Development documents and examples for webcap
url: https://pypi.org/project/webcap/
rpm_license: GPL-v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webcap-0.1.10-1.src.rpm
location_href: Packages/python-webcap-help-0.1.10-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/user-attachments/assets/1cab9ac6-01d8-40dc-a3d4-79127efdbf1b" width="600"/>

  [![Python Version](https://img.shields.io/badge/python-3.9+-8400ff)](https://www.python.org) [![License](https://img.shields.io/badge/license-GPLv3-8400ff.svg)](https://github.com/blacklanternsecurity/webcap/blob/dev/LICENSE) [![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) [![Tests](https://github.com/blacklanternsecurity/webcap/actions/workflows/tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/webcap/actions?query=workflow%3A"tests") [![Codecov](https://codecov.io/gh/blacklanternsecurity/webcap/branch/dev/graph/badge.svg?token=IR5AZBDM5K)](https://codecov.io/gh/blacklanternsecurity/webcap) [![Discord](https://img.shields.io/discord/859164869970362439)](https://discord.com/invite/PZqkgxu5SA)

  **WebCap** is an extremely lightweight headless browser tool capable of web screenshots and more. It doesn't require Selenium, Playwright, Puppeteer, or any other browser automation framework; all it needs is a working Chrome installation.

  ```bash
  pipx install webcap
  ```

  WebCap's most unique feature is its ability to capture not only the **fully-rendered DOM**, but also every snippet of **parsed Javascript** (regardless of inline or external), and the **full response body** of every HTTP request. For convenience, it outputs directly to JSON:



  ![image](https://github.com/user-attachments/assets/60dd2a80-f9c3-438e-8f00-f982c356625d)



  ![image](https://github.com/user-attachments/assets/9360ea5c-bed7-4ede-94a1-49e093bf84e9)







  - [x] Blazing fast screenshots
  - [x] JSON output
  - [x] Full DOM extraction
  - [x] Javascript extraction (inline + external)
  - [ ] Javascript extraction (environment dump)
  - [x] Full network logs (incl. request/response bodies)
  - [x] Status code
  - [x] Title
  - [x] Fuzzy hashing
  - [ ] Technology detection
  - [ ] OCR text extraction
  - [x] Full network logs



  ```bash
  webcap -u http://example.com urls.txt -o ./my_screenshots
  ```



  ```python
  import base64
  from webcap import Browser

  async def main():
      
      browser = Browser()
      
      await browser.start()
      
      webscreenshot = await browser.screenshot("http://example.com")
      
      with open("screenshot.png", "wb") as f:
          f.write(webscreenshot.blob)
      
      await browser.stop()

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



  ```
  usage: webcap [-h] [-u URLS [URLS ...]] [-o OUTPUT] [-r RESOLUTION] [-f] [-t THREADS]
                [--delay DELAY] [-U USER_AGENT] [-H HEADERS [HEADERS ...]] [-p PROXY]
                [-b] [-j] [-d] [-Rs] [-Rq] [-J] [-s] [--debug] [--no-color] [-c CHROME]

  options:
    -h, --help            show this help message and exit
    -u URLS [URLS ...], --urls URLS [URLS ...]
                          URL(s) to capture, or file(s) containing URLs

  Output:
    -o OUTPUT, --output OUTPUT
                          Output directory
    -r RESOLUTION, --resolution RESOLUTION
                          Resolution to capture
    -f, --full-page       Capture the full page (larger resolution images)

  Performance:
    -t THREADS, --threads THREADS
                          Number of threads to use
    --delay DELAY         Delay before capturing (default: 3.0 seconds)

  HTTP:
    -U USER_AGENT, --user-agent USER_AGENT
                          User agent to use
    -H HEADERS [HEADERS ...], --headers HEADERS [HEADERS ...]
                          Additional headers to send in format: 'Header-Name: Header-
                          Value' (multiple supported)
    -p PROXY, --proxy PROXY
                          HTTP proxy to use

  JSON Output:
    -b, --base64          Output each screenshot as base64
    -j, --json            Output JSON
    -d, --dom             Capture the fully-rendered DOM
    -Rs, --responses      Capture the full body of each HTTP response (including API
                          calls etc.)
    -Rq, --requests       Capture the full body of each HTTP request (including API
                          calls etc.)
    -J, --javascript      Capture every snippet of Javascript (inline + external)

  Misc:
    -s, --silent          Silent mode
    --debug               Enable debugging
    --no-color            Disable color output
    -c CHROME, --chrome CHROME
                          Path to Chrome executable
  ```


pkgId: cb2583e5ed0ae20b1226371c627f2f2208769fce6a51116a4e5c62865c3cab6f
name: python-webcode-tk-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for webcode-tk
url: https://github.com/HundredVisionsGuy/webcode-tk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webcode-tk-1.1.3-1.src.rpm
location_href: Packages/python-webcode-tk-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A set of tools for inspecting HTML and CSS code for validity and other
  various checks, such as semantics or required elements.


pkgId: cd395fe07c643f326a49321b5b083bb7be190f61fb059349dfa34e2de8a8bd99
name: python-webdrivermanager-cn
arch: noarch
version: 2.3.1
epoch: 0
release: 1
summary: 基于阿里源开发的WebDriver管理工具
url: https://gitee.com/Joker_JH/webdrivermanagercn
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webdrivermanager-cn-2.3.1-1.src.rpm
location_href: Packages/python-webdrivermanager-cn-2.3.1-1.noarch.rpm
checksum_type: sha256
description:
  > 基于 [阿里源](https://www.npmmirror.com/)、[华为源](https://mirrors.huaweicloud.com/) 整合的WebDriver下载工具
  >
  > 如有新的国内源，欢迎提交Issue，或者提交PR贡献代码



  作者是测开一枚，一直在公司默默无闻的做着自动化测试，偶然公司同事安利 `webdriver_manager`
  这个模块可以有效解决Chrome频繁更新导致ChromeDriver无法使用的问题，可以直接更换国内源，解决默认为GitHub源而导致下载慢或者失败的问题。

  自动化项目引入这个模块后，效果很好，稳定性也很好，且一直相安无事。直到2023年中的某一天，这个平静的情况被打破了。。。

  ChromeDriver官方团队修改了发布方式，导致国内绝大部分的源都无法正确同步新版的ChromeDriver，作者使用的阿里源，也停留在了114版本上，无法继续更新。已向阿里源开发团队提交Issue后，已将新版ChromeDriver源同步完成，但是，已经无法按照新版源更换源地址实现下载了。

  所以，经过作者研究源码，决定重新写一个下载模块，且基于国内源为下载源！



  本模块可以看作是 `webdriver_manager` 模块的国内平替，为那些公司无法通过魔法手段连接GitHub(比如作者公司T_T)
  ，和需要持续更新WebDriver的自动化测试同学们提供服务。



  > 如果有其他 WebDriver 需求请及时提Issue

  | Client  | Windows | MacOS | Linux |
  |:-------:|:-------:|:-----:|:-----:|
  | Chrome  |    ✅    |   ✅   |   ✅   |
  | Firefox |    ✅    |   ✅   |   ✅   |





  - 安装命令：`pip install webdrivermanager_cn`
  - 在线升级：`pip install -U webdrivermanager_cn`



  - ChromeDriver
      - 阿里源
        ```python
        from webdrivermanager_cn import ChromeDriverManagerAliMirror

        driver_path = ChromeDriverManagerAliMirror().install()
        ```
      - 华为源
        ```python
        from webdrivermanager_cn import ChromeDriverManagerHuaweiMirror

        driver_path = ChromeDriverManagerHuaweiMirror().install()
        ```
      - 手动切换源
        ```python
        from webdrivermanager_cn import ChromeDriverManager

        driver = ChromeDriverManager()
        driver.set_ali_mirror()  # 切换为阿里源
        driver.set_huawei_mirror()  # 切换为华为源

        driver_path = driver.install()
        ```

  - Geckodriver
      - 阿里源
        ```python
        from webdrivermanager_cn import GeckodriverManagerAliMirror

        driver_path = GeckodriverManagerAliMirror().install()
        ```
      - 华为源
        ```python
        from webdrivermanager_cn import GeckodriverManagerHuaweiMirror

        driver_path = GeckodriverManagerHuaweiMirror().install()
        ```
      - 手动切换源
        ```python
        from webdrivermanager_cn import GeckodriverManager

        driver = GeckodriverManager()
        driver.set_ali_mirror()  # 切换为阿里源
        driver.set_huawei_mirror()  # 切换为华为源

        driver_path = driver.install()
        ```



  wdmcn内置了一些全局变量，后续会根据需求继续添加，具体请看`config.py`，这里简单列举一下。

  - 日志功能

      - 日志功能默认关闭，可以通过`os.environ['WDM_LOG'] = 'true'`打开，默认为false
      - 日志等级，可以通过`os.environ['WDM_LOG_LEVEL'] = f'{logging.INFO}'`修改，默认等级为INFO
      - 自定义logger，可以通过导入`set_logger()`方法，将您自己的logger添加进来，则日志输出就会使用您的logger记录

  - 定期清理旧的webdriver

      - 如果您使用的wdmcn时间很长以后，webdriver会随着chrome等浏览器版本的迭代越来越多，现在可以默认删除无用的webdriver，可以使用`os.environ['WDM_CACHE_TIME'] = 5`
      设置，默认会清理5天前的webdriver，以减少磁盘占用。



  本项目基于 Apache-2.0 协议开源，目的仅供提供自动化测试工具使用，请勿用于非法用途。对于任何使用者的行为，本项目及本人不承担任何责任。

  本项目中，基于以下网站提供服务，如有服务相关的问题，本人会积极推进，但是无法保证完全解决，请悉知风险。

  - [Gitee](https://gitee.com/)
  - [阿里云开源镜像站](https://www.npmmirror.com/)
  - [华为云开源镜像站](https://mirrors.huaweicloud.com/home)



  如果在使用过程中有任何问题，欢迎提Issue，会在第一时间处理！


pkgId: 9780c664f8c45a00da91ca2cb532a6bffdf41440b82017f71808859f084943fc
name: python-webknossos-help
arch: noarch
version: 0.16.2
epoch: 0
release: 1
summary: Development documents and examples for webknossos
url: https://docs.webknossos.org/webknossos-py
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webknossos-0.16.2-1.src.rpm
location_href: Packages/python-webknossos-help-0.16.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/webknossos)](https://pypi.python.org/pypi/webknossos)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/webknossos.svg)](https://pypi.python.org/pypi/webknossos)
  [![Build Status](https://img.shields.io/github/actions/workflow/status/scalableminds/webknossos-libs/.github/workflows/ci.yml?branch=master)](https://github.com/scalableminds/webknossos-libs/actions?query=workflow%3A%22CI%22)
  [![Documentation](https://img.shields.io/badge/docs-passing-brightgreen.svg)](https://docs.webknossos.org/webknossos-py)
  [![Code Style](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff/)
  [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)

  Python API for working with [WEBKNOSSOS](https://webknossos.org) datasets, annotations, and for WEBKNOSSOS server interaction.

  For the WEBKNOSSOS server, please refer to https://github.com/scalableminds/webknossos.



  - easy-to-use dataset API for reading/writing/editing raw 2D/3D image data and volume annotations/segmentation in WEBKNOSSOS wrap (*.wkw) format
      - add/remove layers
      - update metadata (`datasource-properties.json`)
      - up/downsample layers
      - compress layers
      - add/remove magnifications
      - execute any of the `wkCuber` operations from your code
  - manipulation of WEBKNOSSOS skeleton annotations (*.nml) as Python objects
      - access to nodes, comments, trees, bounding boxes, metadata, etc.
      - create new skeleton annotation from Graph structures or Python objects
  - interaction, connection & scripting with your WEBKNOSSOS instance over the REST API
      - up- & downloading annotations and datasets

  Please refer to [the documentation for further instructions](https://docs.webknossos.org/webknossos-py).


  The `webknossos` package requires at least Python 3.9.

  You can install it from [pypi](https://pypi.org/project/webknossos/), e.g. via pip:

  ```bash
  pip install webknossos
  ```

  To install `webknossos` with the dependencies for all examples, support for more file types, and BioFormats conversions, run: `pip install webknossos[all]`.

  For working with Zeiss CZI microscopy data use `pip install --extra-index-url https://pypi.scm.io/simple/ webknossos[czi]`.

  By default `webknossos` can only distribute any computations through multiprocessing or Slurm. For Kubernetes or Dask install these additional dependencies:

  ```bash
  pip install cluster_tools[kubernetes]
  pip install cluster_tools[dask]
  ```


  See the [examples folder](examples) or the [the documentation](https://docs.webknossos.org/webknossos-py).
  The dependencies for the examples are not installed by default. Use `pip install webknossos[examples]` to install them.


  Please see the [respective documentation page](https://docs.webknossos.org/webknossos-py/CONTRIBUTING.html).


  [AGPLv3](https://www.gnu.org/licenses/agpl-3.0.html)
  Copyright [scalable minds](https://scalableminds.com)


  Excerpts for testing purposes have been sampled from:

  * Dow Jacobo Hossain Siletti Hudspeth (2018). **Connectomics of the zebrafish's lateral-line neuromast reveals wiring and miswiring in a simple microcircuit.** eLife. [DOI:10.7554/eLife.33988](https://elifesciences.org/articles/33988)
  * Zheng Lauritzen Perlman Robinson Nichols Milkie Torrens Price Fisher Sharifi Calle-Schuler Kmecova Ali Karsh Trautman Bogovic Hanslovsky Jefferis Kazhdan Khairy Saalfeld Fetter Bock (2018). **A Complete Electron Microscopy Volume of the Brain of Adult Drosophila melanogaster.** Cell. [DOI:10.1016/j.cell.2018.06.019](https://www.cell.com/cell/fulltext/S0092-8674(18)30787-6). License: [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)
  * Bosch Ackels Pacureanu et al (2022). **Functional and multiscale 3D structural investigation of brain tissue through correlative in vivo physiology, synchrotron microtomography and volume electron microscopy.** Nature Communications. [DOI:10.1038/s41467-022-30199-6](https://www.nature.com/articles/s41467-022-30199-6)
  * Hanke, M., Baumgartner, F. J., Ibe, P., Kaule, F. R., Pollmann, S., Speck, O., Zinke, W. & Stadler, J. (2014). **A high-resolution 7-Tesla fMRI dataset from complex natural stimulation with an audio movie. Scientific Data, 1:140003.** [DOI:10.1038/sdata.2014.3](http://www.nature.com/articles/sdata20143)
  * Sample OME-TIFF files (c) by the OME Consortium [https://downloads.openmicroscopy.org/images/OME-TIFF/2016-06/bioformats-artificial/](https://downloads.openmicroscopy.org/images/OME-TIFF/2016-06/bioformats-artificial/)


pkgId: 946ce5f49463793ec65cf1b44667f82e5a344e50f7c951eac1bec9ca0e2bb40e
name: python-webpush-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for webpush
url: https://github.com/delvinru/webpush-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webpush-1.0.3-1.src.rpm
location_href: Packages/python-webpush-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Simple library for working with [WebPush](https://web.dev/articles/push-notifications-web-push-protocol) in python





  ```bash
  pip install webpush
  ```



  ```python
  import requests
  from webpush import WebPush, WebPushSubscription

  wp = WebPush(private_key="./private_key.pem", public_key="./public_key.pem")


  subscription = WebPushSubscription.model_validate({
      "endpoint": "https://fcm.googleapis.com/fcm/send/...",
      "keys": {
          "auth": "...",
          "p256dh": "..."
      }
  })

  message = wp.get(message='Hello, world!', subscription=subscription)

  requests.post(subscription.endpoint, data=message.encrypted, headers=message.headers)
  ```

  Generate VAPID keys and get applicationServerKey:
  ```
  vapid-gen
  ```

  Private key saved in `public_key.pem` and public key saved in `public_key.pem`.
  Application Server Key saved in `applicationServerKey`



  ```python
  import aiohttp
  from fastapi import FastAPI
  from fastapi.responses import JSONResponse
  from webpush import WebPush, WebPushSubscription

  app = FastAPI()

  wp = WebPush(
      public_key="./public_key.pem",
      private_key="./private_key.pem",
      subscriber="admin@mail.com",
  )


  @app.get("/notification/key")
  async def get_public_key() -> JSONResponse:
      application_server_key = "<generated from vapid-gen>"
      return JSONResponse(content={"public_key": application_server_key})


  @app.post("/notification/subscribe")
  async def subscribe_user(subscription: WebPushSubscription) -> JSONResponse:
      message = wp.get(message="Hello, world", subscription=subscription)
      async with aiohttp.ClientSession() as session:
          await session.post(
              url=str(subscription.endpoint),
              data=message.encrypted,
              headers=message.headers,
          )
      return JSONResponse(content={"status": "ok"})
  ```


  - Why do I need another library?

  The current python libraries that work with Web Push have been written for a very long time, so they do not support typing, try to support outdated encryption algorithms and pull a lot of deprecated dependencies.

  - Why is only `aes128gcm` supported?

  According to the [RFC8192](https://datatracker.ietf.org/doc/html/rfc8291), this is the recommended format. At the moment, all modern systems support this encryption.

  - Will there be support for other encryption modes?

  New, yes, but there are no old ones, for example `aesgcm`

  - Who is this library for?

  You need type support, you're writing a modern backend, minimum number of dependencies.

  And last one, if you have ideas for improvements, bug fixes, feel free to contribute.



  - 1.0.0 - initial release



  - [pywebpush](https://github.com/web-push-libs/pywebpush)
  - [http-ece](https://github.com/web-push-libs/encrypted-content-encoding)


pkgId: aba8171625b1a4f67ec1a666dfb1ced41f44cd5fbff208e2b42c95b4be9ef9f9
name: python-website-as-app-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for website-as-app
url: https://github.com/MarcinOrlowski/website-as-app/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-website-as-app-1.6.0-1.src.rpm
location_href: Packages/python-website-as-app-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  ![WebApp](docs/logo.png)



  Run any website as standalone desktop application



  This tool offers a unique approach to web browsing by opening any webpage in a dedicated
  window using the embedded QT WebEngine. By removing the typical browser UI elements, it effectively
  turns websites into standalone desktop applications. This can be particularly useful if you've ever
  wished to run a frequently used website as a separate app, independent from your main browser.

  It provides a practical solution for those who find themselves juggling numerous browser tabs
  or wanting a clearer separation between work and personal web applications. With each website
  running as its own "app", you gain the benefit of individual entries in your window manager or task
  switcher, potentially improving your workflow organization and efficiency.

  ![WebsiteAsApp in action](docs/screenshot.jpg)

  1. Github website running as standalone app
  2. Own application entry in the task switcher
  3. Dedicated entry in system tray menu for easy access

  Whether you're looking to streamline your digital workspace or simply curious about alternative
  ways to interact with web content, this script presents an interesting concept that might just
  solve a problem you didn't know you had.



  Please refer to the [documentation](docs/README.md) for detailed instructions on how to
  quickly install and start using this tool.



  * Written and copyrighted &copy;2023-2024 by Marcin Orlowski <mail (#) marcinorlowski (.) com>
  * ResponseBuilder is open-sourced software licensed under
    the [MIT license](http://opensource.org/licenses/MIT)


pkgId: ab0ddb876038be966fe0519be00a69da250a09a8966cf910a3bdb7ff40e7c47c
name: python-webslides-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for webslides
url: https://pypi.org/project/webslides/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webslides-0.7.0-1.src.rpm
location_href: Packages/python-webslides-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Webslides is a Python package that allows you to create PowerPoint-like slides in HTML format. It provides several advantages over traditional PowerPoint presentations, such as clickable content, interactivity with plotly figures and other elements, and the ability to create and update a presentation using Python.


  Here is a [live demo](https://datadept.nl/webslides/demo.html) of an output of Webslides, demonstrating most of its features.



  Some key advantages of using HTML over PowerPoint include:

  - Easy to update by rerun of Python code (!)
  - Pages can be as long (or short) as needed, which is handy for taller diagrams
  - Content scaling by browser zoom level
  - Interactive content (!)
    - Internal and external hyperlinks
    - Interactive tooltips
    - Interactive plotly figures
    - Interactivity with any other HTML elements, such as folium geographical maps
  - Can be shared by attachment in email
  - Compact file size



  Let's be honest, potential drawbacks may be:

  - Python is required to create and alter presentations
  - Recipients cannot easily alter the presentation
  - No WYSIWYG editing in a graphical user interface
  - No easy conversion to PDF / print



  Here are some of the things that Webslides does well:

  - Generate an index page based on your content
  - Generate a highlights page, based on your content
  - Includes page navigation to easily navigate through the document
  - Converts plotly figures to HTML



  Webslides has two dependencies:

  - Pandas: a Python package that provides fast, flexible, and expressive data structures for data analysis
  - Plotly: an interactive data visualization library that allows you to create a wide range of charts, graphs, and other visualizations
  - Requests: for retrieving title and footer image

  Webslides uses Pandas to process the content that is included in your presentation.
  The Plotly package is used to convert Plotly figure objects to HTML.



  To install Webslides, simply run the following command:

  `pip install webslides`


  Here are some examples to get you started:
  ```



  import webslides as ws

  ws.demo()
  ```

  ```



  import webslides as ws


  title_page = {
      'title_image_url': 'mylogo.png',   # or insert url
      'title': 'One Page Presentation',
      'summary': {'Context': 'Just some example to get started', 'Author': 'Me'},
  }


  content = {
      'Topcat A': {
          'Subcat X': {
              'page1': {
                  'title': 'Page title 1!',
                  'highlights': ['- highlight 1', '- highlight 2'],
                  'body': 'Content 1: this is a <b>HTML string</b>',
                  'footer': ['- footer 3', '- <i>italic footer 4</i>']
              }
          }
       }
   }


  ws.create(content=content
            , title_page=title_page
            , fname='webslides_basic_example.html'
            , open_in_browser=True
            , show_index_page=False
            , show_topcat=False
            , show_subcat=False
            , show_highlights_page=False
            , show_highlights_only=False
            , custom_css='')
  ```



  The `create` function is used to generate an HTML file with a custom structure based on the provided input parameters. It has the following parameters:



  - **title_page** (dict, _optional_, default=None): A dictionary containing the title page information. It should include an image filename or URL (optional), a title, a summary, and a footer.

  Example input:
  ```
      title_page = {
          'title_image_url': 'myimage.png',
          'title': 'Title of Title Page',
          'summary': {'Summary item 1': 'item text 1', 'Summary item 2': 'item text 2'},
          'footer': ['- use custom title image via the title_image_url parameter', '- footer2']
      }
  ```

  - **content** (dict, _optional_, default=None): A dictionary containing the content pages organized by top categories and subcategories.


    Example input:
  ```
  content = {
      'Topcat A': {
          'Subcat X': {
              'page1': {
                  'title': 'Page Title 1 - HTML body',
                  'highlights': ['- highlight 1', '- highlight 2'],
                  'body': 'Content 1: this is a <b>HTML string</b>',
                  'footer': ['- footer 1a', '- <i>italic footer 1b</i>'],
                  'show': True},
                  ...
              },
          ...
          },
      ...
  }
  ```
  - **fname** (str, _optional_, default='output.html'): The output filename or path+filename for the generated HTML file. If path is not existent, a subfolder wsout will be created.

  - **open_in_browser** (bool, _optional_, default=True): If set to True, the generated HTML file will be opened in the default web browser.

  - **show_index_page** (bool, _optional_, default=False): If set to True, an index page will be displayed with links to all content pages.

  - **show_highlights_page** (bool, _optional_, default=False): If set to True, a highlights page will be displayed with a summary of the highlights from each content page.

  - **show_topcat** (bool, _optional_, default=False): If set to True, the top category will be displayed in the index and highlights pages.

  - **show_subcat** (bool, _optional_, default=False): If set to True, the subcategory will be displayed in the index and highlights pages.

  - **show_highlights_only** (bool, _optional_, default=False): If set to True, only content pages with highlights will be shown in the index and highlights pages.

  - **footer_image_url** (str, _optional_, default=None): Filename or web url of image to be used for logo in footer.

  - **embed_images** : (bool, optional, default = True): If True, images will be embedded in the HTML file. Embedding increases file size.

  - **contents_title** : (str, optional, default = 'Contents'): Heading of the contents page.

  - **tooltips** (dict, _optional_, default=None): Dictionary with keys 'topcats' and 'subcats' and with topcat/subcat as keys, with each a dict wit keys and values with the respective topcat names and tooltip texts.

  - **custom_css** (str, _optional_, default=None): String with custom CSS code to apply to output HTML. Can be used to adjust or overrule any styling, like logo size, background color etc.


  - Change background color to white, font to Arial, remove rounded page corners:
  ```
  custom_css = "body {font-family: Arial, sans-serif; background-color: #FFF} .page {border-radius:0px;}"
  ```



  Each content page dictionary within the content parameter can include the following keys:

  - **title** (str, _mandatory_): The title of the content page.

  - **body** (str or object, _mandatory_): The body of the content page. It can be a string containing HTML or an object (e.g., a Plotly figure).

  - **highlights** (list of str, _optional_): A list of highlights for the content page. If not provided, no highlights will be displayed, and the page will not have a lightbulb icon in the index page.

  - **footer** (list of str, _optional_): A list of footer items for the content page. Each item can include HTML tags.

  - **show** (bool, _optional_): If set to False, the content page will be hidden in the output. If not provided or set to True, the page will be shown.


pkgId: c87fc9887701163f099f61b040038a1277ae312a70a771731467dbd07efc129b
name: python-webtypy-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for webtypy
url: https://github.com/pyodide/webtypy
rpm_license: MPL 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webtypy-0.1.7-1.src.rpm
location_href: Packages/python-webtypy-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  Webtypy is a library created with the aim of enhancing the capabilities of your IDE during web development. This module contains the DOM types for a majority of the web APIs commonly used in a web browser, allowing developers to gain insights about the Web API.

  With webtypy, developers can receive hints from their IDE about available functions, classes, function parameters, and their associated types. These features are intended to assist in the development process and potentially improve code accuracy.

  The APIs within webtypy are generated from the specifications for CSS, HTML, and JavaScript, providing developers with a resource that keeps up with current web standards.



  To install webtypy, you can use the following command:

  `pip install webtypy`


  **Remark**: Webtypy is primarily a development-time library. It is designed to assist developers during the development process by providing insights about the Web API. As such, it is not typically required in a production environment or at runtime. Its main function is to enhance the development experience and is not needed once the application is deployed.



  Webtypy is designed to enhance your IDE's capabilities and streamline your development process. It integrates directly into your development environment and can be utilized in various ways. Here are a couple of examples:

  **Code Completion**: One way to leverage webtypy is through code completion. As you type, your IDE can suggest possible completions based on webtypy's API data. This feature can be typically invoked by pressing 'Control+Space'.

  **Hovering Information**: Another example is the detailed information provided when you hover over an element in your code. By placing your mouse pointer over an element, you can view additional details like associated types and the definition of the element.

  These are just a couple of examples, and the exact usage might vary based on the IDE you're using. Be sure to check your IDE's documentation for more specific instructions on utilizing features like code completion and hovering information.



  A few details about the generation process of the .pyi (Python Interface file) can be found [here](GENERATION.md).



  webtypy uses the [Mozilla Public License Version
  2.0](https://choosealicense.com/licenses/mpl-2.0/).


pkgId: d57dc4d5102798b44643e28fecc869a4fba3a888bd5e25be674848515aba92ea
name: python-webuiapi-help
arch: noarch
version: 0.9.17
epoch: 0
release: 1
summary: Development documents and examples for webuiapi
url: https://github.com/mix1009/sdwebuiapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-webuiapi-0.9.17-1.src.rpm
location_href: Packages/python-webuiapi-help-0.9.17-1.noarch.rpm
checksum_type: sha256
description:
  API client for AUTOMATIC1111/stable-diffusion-webui

  Supports txt2img, img2img, extra-single-image, extra-batch-images API calls.

  API support have to be enabled from webui. Add --api when running webui.
  It's explained [here](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/API).

  You can use --api-auth user1:pass1,user2:pass2 option to enable authentication for api access.
  (Since it's basic http authentication the password is transmitted in cleartext)

  API calls are (almost) direct translation from http://127.0.0.1:7860/docs as of 2022/11/21.



  ```
  pip install webuiapi
  ```



  webuiapi_demo.ipynb contains example code with original images. Images are compressed as jpeg in this document.


  ```
  import webuiapi


  api = webuiapi.WebUIApi()













  api.set_auth('username', 'password')
  ```


  ```
  result1 = api.txt2img(prompt="cute squirrel",
                      negative_prompt="ugly, out of frame",
                      seed=1003,
                      styles=["anime"],
                      cfg_scale=7,










                      )

  result1.images


  result1.image


  result1.info


  result1.parameters

  result1.image
  ```
  ![txt2img](https://user-images.githubusercontent.com/1288793/200459205-258d75bb-d2b6-4882-ad22-040bfcf95626.jpg)



  ```
  result2 = api.img2img(images=[result1.image], prompt="cute cat", seed=5555, cfg_scale=6.5, denoising_strength=0.6)
  result2.image
  ```
  ![img2img](https://user-images.githubusercontent.com/1288793/200459294-ab1127e5-04e5-47ac-82b2-2bbd0648402a.jpg)


  ```
  from PIL import Image, ImageDraw

  mask = Image.new('RGB', result2.image.size, color = 'black')

  draw = ImageDraw.Draw(mask)
  draw.ellipse((210,150,310,250), fill='white')
  draw.ellipse((80,120,160,120+80), fill='white')

  mask
  ```
  ![mask](https://user-images.githubusercontent.com/1288793/200459372-7850c6b6-27c5-435a-93e2-8710948d316a.jpg)

  ```
  inpainting_result = api.img2img(images=[result2.image],
                                  mask_image=mask,
                                  inpainting_fill=1,
                                  prompt="cute cat",
                                  seed=104,
                                  cfg_scale=5.0,
                                  denoising_strength=0.7)
  inpainting_result.image
  ```
  ![img2img_inpainting](https://user-images.githubusercontent.com/1288793/200459398-9c1004be-1352-4427-bc00-442721a0e5a1.jpg)


  ```
  result3 = api.extra_single_image(image=result2.image,
                                   upscaler_1=webuiapi.Upscaler.ESRGAN_4x,
                                   upscaling_resize=1.5)
  print(result3.image.size)
  result3.image
  ```
  (768, 768)

  ![extra_single_image](https://user-images.githubusercontent.com/1288793/200459455-8579d740-3d8f-47f9-8557-cc177b3e99b7.jpg)


  ```
  result4 = api.extra_batch_images(images=[result1.image, inpainting_result.image],
                                   upscaler_1=webuiapi.Upscaler.ESRGAN_4x,
                                   upscaling_resize=1.5)
  result4.images[0]
  ```
  ![extra_batch_images_1](https://user-images.githubusercontent.com/1288793/200459540-b0bd2931-93db-4d03-9cc1-a9f5e5c89745.jpg)
  ```
  result4.images[1]
  ```
  ![extra_batch_images_2](https://user-images.githubusercontent.com/1288793/200459542-aa8547a0-f6db-436b-bec1-031a93a7b1d4.jpg)


  txt2img, img2img, extra_single_image, extra_batch_images support async api call with use_async=True parameter. You need asyncio, aiohttp packages installed.
  ```
  result = await api.txt2img(prompt="cute kitten",
                      seed=1001,
                      use_async=True
                      )
  result.image
  ```


  Scripts from AUTOMATIC1111's Web UI are supported, but there aren't official models that define a script's interface.

  To find out the list of arguments that are accepted by a particular script look up the associated python file from
  AUTOMATIC1111's repo `scripts/[script_name].py`. Search for its `run(p, **args)` function and the arguments that come
  after 'p' is the list of accepted arguments


  ```
  (scripts/xyz_grid.py file from AUTOMATIC1111's repo)

      def run(self, p, x_type, x_values, y_type, y_values, z_type, z_values, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, margin_size):
      ...
  ```
  List of accepted arguments:
  * _x_type_: Index of the axis for X axis. Indexes start from [0: Nothing]
  * _x_values_: String of comma-separated values for the X axis
  * _y_type_: Index of the axis type for Y axis. As the X axis, indexes start from [0: Nothing]
  * _y_values_: String of comma-separated values for the Y axis
  * _z_type_: Index of the axis type for Z axis. As the X axis, indexes start from [0: Nothing]
  * _z_values_: String of comma-separated values for the Z axis
  * _draw_legend_: "True" or "False". IMPORTANT: It needs to be a string and not a Boolean value
  * _include_lone_images_: "True" or "False". IMPORTANT: It needs to be a string and not a Boolean value
  * _include_sub_grids_: "True" or "False". IMPORTANT: It needs to be a string and not a Boolean value
  * _no_fixed_seeds_: "True" or "False". IMPORTANT: It needs to be a string and not a Boolean value
  * margin_size: int value
  ```

  XYZPlotAvailableTxt2ImgScripts = [
      "Nothing",
      "Seed",
      "Var. seed",
      "Var. strength",
      "Steps",
      "Hires steps",
      "CFG Scale",
      "Prompt S/R",
      "Prompt order",
      "Sampler",
      "Checkpoint name",
      "Sigma Churn",
      "Sigma min",
      "Sigma max",
      "Sigma noise",
      "Eta",
      "Clip skip",
      "Denoising",
      "Hires upscaler",
      "VAE",
      "Styles",
  ]

  XYZPlotAvailableImg2ImgScripts = [
      "Nothing",
      "Seed",
      "Var. seed",
      "Var. strength",
      "Steps",
      "CFG Scale",
      "Image CFG Scale",
      "Prompt S/R",
      "Prompt order",
      "Sampler",
      "Checkpoint name",
      "Sigma Churn",
      "Sigma min",
      "Sigma max",
      "Sigma noise",
      "Eta",
      "Clip skip",
      "Denoising",
      "Cond. Image Mask Weight",
      "VAE",
      "Styles",
  ]


  XAxisType = "Steps"
  XAxisValues = "20,30"
  XAxisValuesDropdown = ""
  YAxisType = "Sampler"
  YAxisValues = "Euler a, LMS"
  YAxisValuesDropdown = ""
  ZAxisType = "Nothing"
  ZAxisValues = ""
  ZAxisValuesDropdown = ""
  drawLegend = "True"
  includeLoneImages = "False"
  includeSubGrids = "False"
  noFixedSeeds = "False"
  marginSize = 0




  result = api.txt2img(
                      prompt="cute girl with short brown hair in black t-shirt in animation style",
                      seed=1003,
                      script_name="X/Y/Z Plot",
                      script_args=[
                          XYZPlotAvailableTxt2ImgScripts.index(XAxisType),
                          XAxisValues,
                          XAxisValuesDropdown,
                          XYZPlotAvailableTxt2ImgScripts.index(YAxisType),
                          YAxisValues,
                          YAxisValuesDropdown,
                          XYZPlotAvailableTxt2ImgScripts.index(ZAxisType),
                          ZAxisValues,
                          ZAxisValuesDropdown,
                          drawLegend,
                          includeLoneImages,
                          includeSubGrids,
                          noFixedSeeds,
                          marginSize,                        ]
                      )

  result.image
  ```
  ![txt2img_grid_xyz](https://user-images.githubusercontent.com/1288793/222345625-dc2e4090-6786-4a53-8619-700dc2f12412.jpg)



  ```

  options = api.get_options()


  options = {}
  options['sd_model_checkpoint'] = 'model.ckpt [7460a6fa]'
  api.set_options(options)





  api.get_sd_models()


  api.get_samplers()
  api.get_cmd_flags()
  api.get_hypernetworks()
  api.get_face_restorers()
  api.get_realesrgan_models()
  api.get_prompt_styles()
  api.get_artist_categories() # deprecated ?
  api.get_artists() # deprecated ?
  api.get_progress()
  api.get_embeddings()
  api.get_cmd_flags()
  api.get_scripts()
  api.get_schedulers()
  api.get_memory()


  api.interrupt()
  api.skip()
  ```


  ```

  old_model = api.util_get_current_model()


  models = api.util_get_model_names()


  api.util_get_sampler_names()


  api.util_get_scheduler_names()


  api.refresh_checkpoints()


  api.util_set_model(models[0])


  api.util_set_model('robodiffusion')


  api.util_wait_for_ready()

  ```



  ```
  r = api.txt2img(prompt='photo of a cute girl with green hair <lora:Moxin_10:0.6> shuimobysim __juice__',
                  seed=1000,
                  save_images=True,
                  alwayson_scripts={"Simple wildcards":[]} # wildcards extension doesn't accept more parameters.
                 )
  r.image
  ```


  ```

  mki = webuiapi.ModelKeywordInterface(api)
  mki.get_keywords()
  ```
  ModelKeywordResult(keywords=['nousr robot'], model='robo-diffusion-v1.ckpt', oldhash='41fef4bd', match_source='model-keyword.txt')



  ```


  r = api.img2img(prompt='sunset', images=[pil_img], cfg_scale=7.5, image_cfg_scale=1.5)
  r.image
  ```


  ```


  api.controlnet_model_list()
  ```
  <pre>
  ['control_v11e_sd15_ip2p [c4bb465c]',
   'control_v11e_sd15_shuffle [526bfdae]',
   'control_v11f1p_sd15_depth [cfd03158]',
   'control_v11p_sd15_canny [d14c016b]',
   'control_v11p_sd15_inpaint [ebff9138]',
   'control_v11p_sd15_lineart [43d4be0d]',
   'control_v11p_sd15_mlsd [aca30ff0]',
   'control_v11p_sd15_normalbae [316696f1]',
   'control_v11p_sd15_openpose [cab727d4]',
   'control_v11p_sd15_scribble [d4ba51ff]',
   'control_v11p_sd15_seg [e1f51eb9]',
   'control_v11p_sd15_softedge [a8575a2a]',
   'control_v11p_sd15s2_lineart_anime [3825e83e]',
   'control_v11u_sd15_tile [1f041471]']
   </pre>

  ```
  api.controlnet_version()
  api.controlnet_module_list()
  ```

  ```

  r = api.txt2img(prompt="photo of a beautiful girl with blonde hair", height=512, seed=100)
  img = r.image
  img
  ```
  ![cn1](https://user-images.githubusercontent.com/1288793/222315754-43c6dc8c-2a62-4a31-b51a-f68523118e0d.png)

  ```


  unit1 = webuiapi.ControlNetUnit(image=img, module='canny', model='control_v11p_sd15_canny [d14c016b]')

  r = api.txt2img(prompt="photo of a beautiful girl", controlnet_units=[unit1])
  r.image
  ```

  ![cn2](https://user-images.githubusercontent.com/1288793/222315791-c6c480eb-2987-4044-b673-5f2cb6135f87.png)


  ```

  unit1 = webuiapi.ControlNetUnit(image=img, module='canny', model='control_v11p_sd15_canny [d14c016b]')
  unit2 = webuiapi.ControlNetUnit(image=img, module='depth', model='control_v11f1p_sd15_depth [cfd03158]', weight=0.5)

  r2 = api.img2img(prompt="girl",
              images=[img],
              width=512,
              height=512,
              controlnet_units=[unit1, unit2],
              sampler_name="Euler a",
              cfg_scale=7,
             )
  r2.image
  ```
  ![cn3](https://user-images.githubusercontent.com/1288793/222315816-1155b0c2-570d-4455-a68e-294fc7061b0a.png)

  ```
  r2.images[1]
  ```
  ![cn4](https://user-images.githubusercontent.com/1288793/222315836-9a26afec-c407-426b-9a08-b2cef2a32ab1.png)

  ```
  r2.images[2]
  ```
  ![cn5](https://user-images.githubusercontent.com/1288793/222315859-e6b6286e-854d-40c1-a516-5a08c827c49a.png)


  ```
  r = api.controlnet_detect(images=[img], module='canny')
  r.image
  ```




  ```

  adiff = webuiapi.AnimateDiff(model='mm_sd15_v3.safetensors',
                               video_length=24,
                               closed_loop='R+P',
                               format=['GIF'])

  r = api.txt2img(prompt='cute puppy', animatediff=adiff)


  r.image.save('puppy.gif', save_all=True)


  from IPython.display import HTML
  HTML('<img src="data:image/gif;base64,{0}"/>'.format(r.json['images'][0]))
  ```


  ```

  rembg = webuiapi.RemBGInterface(api)
  r = rembg.rembg(input_image=img, model='u2net', return_mask=False)
  r.image
  ```



  ```python


  segment = webuiapi.SegmentAnythingInterface(api)


  sam_result = segment.sam_predict(
      image=img,
      sam_positive_points=[(0.5, 0.25), (0.75, 0.75)],
      
  )


  sam_result2 = segment.sam_predict(
      image=img,
      dino_enabled=True,
      dino_text_prompt="A text prompt for GroundingDINO",
      
  )


  dilation_result = segment.dilate_mask(
      image=img,
      mask=sam_result.masks[0],  # using the first mask from the SAM prediction
      dilate_amount=30
  )


  semantic_seg_result = segment.sam_and_semantic_seg_with_cat_id(
      image=img,
      category="1+2+3",  # Category IDs separated by '+'
      
  )
  ```



  ```python


  tagger = webuiapi.TaggerInterface(api)
  result = tagger.tagger_interrogate(image)
  print(result)

  ```


  ```


  import webuiapi

  api = webuiapi.WebUIApi()

  ads = webuiapi.ADetailer(ad_model="face_yolov8n.pt")

  result1 = api.txt2img(prompt="cute squirrel",
                      negative_prompt="ugly, out of frame",
                      seed=-1,
                      styles=["anime"],
                      cfg_scale=7,
                      adetailer=[ads],
                      steps=30,
                      enable_hr=True,
                      denoising_strength=0.5
              )



  img = result1.image
  img



  file_path = "output_image.png"
  result1.image.save(file_path)
  ```



  ```
  import webuiapi
  from PIL import Image

  img = Image.open("/path/to/your/image.jpg")

  ads = webuiapi.ADetailer(ad_model="face_yolov8n.pt")

  api = webuiapi.WebUIApi()

  result1 = api.img2img(
      images=[img],
      prompt="a cute squirrel",
      steps=25,
      seed=-1,
      cfg_scale=7,
      denoising_strength=0.5,
      resize_mode=2,
      width=512,
      height=512,
      adetailer=[ads],
  )

  file_path = "img2img_output_image.png"
  result1.image.save(file_path)
  ```


  ```
  import webuiapi
  from PIL import Image

  api = webuiapi.WebUIApi()

  img = Image.open("/path/to/your/image.jpg")

  interrogate_result = api.interrogate(image=img, model="deepdanbooru")




  prompt = interrogate_result.info
  prompt


  print(prompt)
  ```



  ```
  import webuiapi
  from PIL import Image

  img = Image.open("/path/to/your/image.jpg")

  api = webuiapi.WebUIApi()

  your_desired_face = Image.open("/path/to/your/desired/face.jpeg")

  reactor = webuiapi.ReActor(
      img=your_desired_face,
      enable=True
  )

  result1 = api.img2img(
      images=[img],
      prompt="a cute squirrel",
      steps=25,
      seed=-1,
      cfg_scale=7,
      denoising_strength=0.5,
      resize_mode=2,
      width=512,
      height=512,
      reactor=reactor
  )

  file_path = "face_swapped_image.png"
  result1.image.save(file_path)
  ```




  https://github.com/ashen-sensored/sd_webui_SAG

  ```
  import webuiapi
  from PIL import Image

  img = Image.open("/path/to/your/image.jpg")

  api = webuiapi.WebUIApi()

  your_desired_face = Image.open("/path/to/your/desired/face.jpeg")

  sag = webuiapi.Sag(
      enable=True,
      scale=0.75,
      mask_threshold=1.00
  )

  result1 = api.img2img(
      images=[img],
      prompt="a cute squirrel",
      steps=25,
      seed=-1,
      cfg_scale=7,
      denoising_strength=0.5,
      resize_mode=2,
      width=512,
      height=512,
      sag=sag
  )

  file_path = "face_swapped_image.png"
  result1.image.save(file_path)
  ```




  This is an unofficial implementation to use the api of promptgen.
  Before installing the extension you have to check if you already have an extension called Promptgen. If so, you need to uninstall it.
  Once uninstalled you can install it in two ways:


  ![image](https://github.com/davidmartinrius/sdwebuiapi/assets/16558194/d879719f-bb9f-44a7-aef7-b893d117bbea)



  cd stable-diffusion-webui/extensions

  git clone -b api-implementation https://github.com/davidmartinrius/stable-diffusion-webui-promptgen.git

  Once installed:
  ```
  api = webuiapi.WebUIApi()

  result = api.list_prompt_gen_models()
  print("list of models")
  print(result)



  text = "a box"

  To create a prompt from a text:

  result = api.prompt_gen(text=text)


  result = api.prompt_gen(text=text, model_name="AUTOMATIC/promptgen-majinai-unsafe")


  result =  api.prompt_gen(
          text=text,
          model_name="AUTOMATIC/promptgen-majinai-unsafe",
          batch_count= 1,
          batch_size=10,
          min_length=20,
          max_length=150,
          num_beams=1,
          temperature=1,
          repetition_penalty=1,
          length_preference=1,
          sampling_mode="Top K",
          top_k=12,
          top_p=0.15
      )



  ```



  In both cases, it is needed cfg_scale = 1, sampler_name = "Euler", scheduler = "Simple" and in txt2img enable_hr=False


  ```
  import webuiapi

  result1 = api.txt2img(prompt="cute squirrel",
                      negative_prompt="ugly, out of frame",
                      seed=-1,
                      styles=["anime"],
                      cfg_scale=1,
                      steps=20,
                      enable_hr=False,
                      denoising_strength=0.5,
                      sampler_name= "Euler",
                      scheduler= "Simple"
              )



  img = result1.image
  img



  file_path = "output_image.png"
  result1.image.save(file_path)

  ```



  ```
  import webuiapi
  from PIL import Image

  img = Image.open("/path/to/your/image.jpg")

  api = webuiapi.WebUIApi()

  result1 = api.img2img(
      images=[img],
      prompt="a cute squirrel",
      steps=20,
      seed=-1,
      cfg_scale=1,
      denoising_strength=0.5,
      resize_mode=2,
      width=512,
      height=512,
      sampler_name= "Euler",
      scheduler= "Simple"
  )

  file_path = "face_swapped_image.png"
  result1.image.save(file_path)

  ```


pkgId: a36becf5a971ca70221c109265b5d3f89d7a1ebd90e8c6397f112fe126912a7e
name: python-wechat-django-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for wechat-django
url: https://github.com/Xavier-Lam/wechat-django
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wechat-django-0.4.0-1.src.rpm
location_href: Packages/python-wechat-django-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  - [功能](#%e5%8a%9f%e8%83%bd)
  - [安装及配置](#%e5%ae%89%e8%a3%85%e5%8f%8a%e9%85%8d%e7%bd%ae)
    - [初次安装](#%e5%88%9d%e6%ac%a1%e5%ae%89%e8%a3%85)
    - [直接加入项目](#%e7%9b%b4%e6%8e%a5%e5%8a%a0%e5%85%a5%e9%a1%b9%e7%9b%ae)
    - [更新](#%e6%9b%b4%e6%96%b0)
    - [配置](#%e9%85%8d%e7%bd%ae)
    - [日志](#%e6%97%a5%e5%bf%97)
    - [注意事项](#%e6%b3%a8%e6%84%8f%e4%ba%8b%e9%a1%b9)
  - [部分功能使用说明](#%e9%83%a8%e5%88%86%e5%8a%9f%e8%83%bd%e4%bd%bf%e7%94%a8%e8%af%b4%e6%98%8e)
    - [网页授权](#%e7%bd%91%e9%a1%b5%e6%8e%88%e6%9d%83)
    - [小程序授权](#%e5%b0%8f%e7%a8%8b%e5%ba%8f%e6%8e%88%e6%9d%83)
      - [小程序信息加解密及用户数据更新](#%e5%b0%8f%e7%a8%8b%e5%ba%8f%e4%bf%a1%e6%81%af%e5%8a%a0%e8%a7%a3%e5%af%86%e5%8f%8a%e7%94%a8%e6%88%b7%e6%95%b0%e6%8d%ae%e6%9b%b4%e6%96%b0)
    - [主动调用微信api](#%e4%b8%bb%e5%8a%a8%e8%b0%83%e7%94%a8%e5%be%ae%e4%bf%a1api)
    - [自定义微信回复](#%e8%87%aa%e5%ae%9a%e4%b9%89%e5%be%ae%e4%bf%a1%e5%9b%9e%e5%a4%8d)
    - [微信支付](#%e5%be%ae%e4%bf%a1%e6%94%af%e4%bb%98)
      - [统一下单](#%e7%bb%9f%e4%b8%80%e4%b8%8b%e5%8d%95)
      - [订单更新(回调)通知](#%e8%ae%a2%e5%8d%95%e6%9b%b4%e6%96%b0%e5%9b%9e%e8%b0%83%e9%80%9a%e7%9f%a5)
    - [django-rest-framework](#django-rest-framework)
  - [后台使用简介](#%e5%90%8e%e5%8f%b0%e4%bd%bf%e7%94%a8%e7%ae%80%e4%bb%8b)
  - [示例项目](#%e7%a4%ba%e4%be%8b%e9%a1%b9%e7%9b%ae)
  - [TODOS:](#todos)
    - [计划的功能](#%e8%ae%a1%e5%88%92%e7%9a%84%e5%8a%9f%e8%83%bd)
    - [已知bugs](#%e5%b7%b2%e7%9f%a5bugs)
  - [Changelog](#changelog)

  * 公众号管理
  * 同步用户及用户查看,备注,用户标签管理
  * 菜单同步,查看及发布
  * 同步公众号自动回复,管理自动回复,转发和自定义自动回复业务,接收消息日志
  * 模板消息模板的同步及发送
  * 永久素材,图文的同步及查看
  * 微信网页授权
  * [微信jsapi配置](docs/cookbook/web.md#jsapi)
  * 主动调用微信api封装
  * 微信支付api封装
  * 微信支付订单管理及信号
  * 后台权限管理
  * django-rest-framework APIView兼容
  * 迁移公众号自动回复/菜单/素材(不建议)


  1. 运行**pip install wechat-django[cryptography]** 或 **pip install wechat-django[pycrypto]** 安装
  2. 在settings.py的**INSTALLED_APPS中添加wechat_django**
  3. 运行**manage.py migrate wechat_django** 来更新数据库结构
  4. 在urls.py 中引入wechat_django.sites.wechat.urls, 将其配置到urlpatterns中
  5. 在settings.py中,设置`USE_TZ = True`
  至此,您已可以开始轻松使用wechat_django.项目尚未提供具体的使用文档,如需客制化需求,烦请先阅读代码

  想使用最新特性或是自行编辑代码,可clone本项目后,采用pip install -e 直接安装到你的django项目目录

  1. 运行**pip install -U wechat-django**
  2. 运行**python manage.py migrate** 来更新数据库结构

  一般而言,默认配置足以满足需求
  | 参数名 | 默认值 | 说明 |
  | --- | --- | --- |
  | WECHAT_SITE_HOST | None | 用于接收微信回调的默认域名 |
  | WECHAT_SITE_HTTPS | True | 接收微信回调域名是否是https |
  | WECHAT_PATCHADMINSITE | True | 是否将django默认的adminsite替换为wechat_django默认的adminsite, 默认替换 |
  | WECHAT_SESSIONSTORAGE | "django.core.cache.cache" | 用于存储微信accesstoken等数据的[`wechatpy.session.SessionStorage`](https://wechatpy.readthedocs.io/zh_CN/master/quickstart.html#id10) 对象,或接收 `wechat_django.models.WeChatApp` 对象并生成其实例的工厂方法 |
  | WECHAT_MESSAGETIMEOFFSET | 180 | 微信请求消息时,timestamp与服务器时间差超过该值的请求将被抛弃 |
  | WECHAT_MESSAGENOREPEATNONCE | True | 是否对微信消息防重放检查 默认检查 |

  | logger | 说明 |
  | --- | --- |
  | wechat.admin.{appname} | admin异常日志 最低级别warning |
  | wechat.api.{appname} | api日志 最低级别debug |
  | wechat.handler.{appname} | 消息处理日志 最低级别debug |
  | wechat.oauth.{appname} | 网页授权异常日志 最低级别warning |
  | wechat.site.{appname} | 站点view异常日志(如素材代理) 最低级别warning |

  * 框架默认采用django的cache管理accesstoken,如果有多个进程,或是多台机器部署,请确保所有worker使用公用cache以免造成token争用,如果希望不使用django的cache管理accesstoken,可以在配置项中定义SessionStorage
  * 请确保在https环境下部署,否则有secretkey泄露的风险


  可通过`wechat_django.oauth.wechat_auth`装饰器进行网页授权,授权后,request将被附上一个名为wechat的`wechat_django.oauth.WeChatOAuthInfo` 对象,可通过 request.wechat.user 拿到`wechat_django.models.WeChatUser`实例,通过 request.wechat.app 拿到`wechat_django.models.WeChatApp`实例,以下是一个基本示例
      from wechat_django import wechat_auth
      @wechat_auth("your_app_name")
      def your_view(request, *args, **kwargs):
          """:type request: wechat_django.requests.WeChatOAuthRequest"""
          user = request.wechat.user
  对于默认重定向行为不满意的,可以自定义response,具体的参数说明参见`wechat_django.oauth.wechat_auth`装饰器的docstring
  对于class based view,可继承`wechat_django.oauth.WeChatOAuthView`类,具体参见代码

  通过`wechat_django.models.WeChatApp.auth`进行授权,输入客户端传来的code, 输出一个用户对象以及原始响应.这个方法只能拿到用户的openid与unionid.
      from wechat_django.models import WeChatApp
      app = WeChatApp.objects.get_by_name("your app name")
      user, data = app.auth(code)
  对于授权后得到的session_key,框架会持久化至数据库,此后可以通过调用`wechat_django.models.WeChatUser.session`来执行相关操作.
  auth方法同样适用于网页授权,第二个参数填写网页授权的scope,默认base.

  对于已经进行过小程序授权并且session_key尚未过期的用户,可以使用`wechat_django.models.Session.decrypt_message`来解密客户端传来的敏感数据
      encrypted_data = ""
      iv = ""
      try:
          data = user.session.decrypt_message(
              encrypted_data, iv)
      except ValueError:
          pass # 无法正确解密数据 session_key可能过期了
  亦可使用`wechat_django.models.Session.validate_message`来校验客户端传来的数据
      from wechatpy.exceptions import InvalidSignatureException
      signature = ""
      raw_data = ""
      try:
          data = user.session.validate_message(raw_data, signature)
      except InvalidSignatureException:
          pass # 签名错误 session_key可能过期了
  客户端调用`wx.getUserInfo`,可将rawData与signature传递至后端,后端通过调用`wechat_django.models.Session.validate_message`与`wechat_django.models.User.update`来更新用户信息
      from django.http.response import HttpResponse
      from wechatpy.exceptions import InvalidSignatureException
      signature = request.POST["signature"]
      raw_data = request.POST["rawData"]
      try:
          data = user.session.validate_message(raw_data, signature)
      except InvalidSignatureException:
          return HttpResponse(status=401)
  使用update方法更新用户数据
      user.update(data)

      from wechat_django.models import WeChatApp
      app = WeChatApp.get_by_name("your app name")
      data = app.client.user.get_followers()
  具体client的使用方式,请移步[wechatpy文档](https://wechatpy.readthedocs.io/zh_CN/master/client/index.html)

  在后台配置自定义回复,填写自定义回复处理代码的路径,代码须由 `wechat_django.handler.message_handler` 装饰对应的方法接收一个 `wechat_django.models.WeChatMessageInfo` 对象,返回字符串或一个 [`wechatpy.replies.BaseReply`](https://wechatpy.readthedocs.io/zh_CN/master/replies.html) 对象
      from wechat_django import message_handler
      @message_handler
      def custom_business(message):
          """
          """
          user = message.user
          msg = message.message
          text = "hello, {0}! we received a {1} message.".format(
              user, msg.type)
          return TextReply(content=text.encode())

  使用微信支付,需要在INSTALLED_APP的`wechat_django`后添加`wechat_django.pay`.

      from wechat_django.models import WeChatApp
      app = WeChatApp.objects.get_by_name("your app name")
      order = app.pay.create_order(
          user="user-instance", body="body", total_fee=1,
          out_trade_no="***debug***20190613001") # 也可以用openid="openid"代替user参数
      prepay = order.prepay(request)
  将jsapi参数交给前端
      jsapi_params = order.jsapi_params(prepay["prepay_id"])
  主动查询订单状态
      order.sync()

  当订单更新时,会发出`wechat_django.pay.signals.order_updated`信号,sender为订单`wechat_django.utils.func.Static("{appname}.{payname}")`.信号提供4个变量
  | 变量 | 说明 |
  | --- | --- |
  | result | 订单结果(`wechat_django.pay.models.UnifiedOrderResult`) |
  | order | 更新的订单(`wechat_django.pay.models.UnifiedOrder`) |
  | state | 订单状态(`wechat_django.pay.models.UnifiedOrderResult.State`) |
  | attach | 结果附带的信息(生成订单时传给微信服务器的attach) |
  使用示例
      from django.dispatch import receiver
      from wechat_django.pay import signals
      @receiver(signals.order_updated)
      def order_updated(result, order, state, attach):
          if state == UnifiedOrderResult.State.SUCCESS:
              pass
  > 注意! 每次主动调用,微信通知或是后台重新触发都会发送信号,请自行确保订单成功信号逻辑只执行一次!

  本项目class-based OAuth授权兼容django-rest-framework.
    1. 构造一个继承`wechat_django.oauth.WeChatOAuthViewMixin`的视图类;
    2. 在视图类中定义`appname`属性;
    3. 根据需要,定义`permission_classes`(如若资源必须授权才可访问,请在permission_classes中添加`wechat_django.oauth.WeChatAuthenticated`);
    4. 根据需要,自行处理异常,在`handle_exception`方法中捕获`rest_framework.exceptions.NotAuthenticated`,自行处理.
  可以参见示例项目的[rest.py](sample/wechat/rest.py)文件.

  参见[管理后台使用简介](docs/admin.md) 文档

  可参考[本项目sample文件夹](sample)

  * 是否可做成migrate权限全自助?重构权限模块?
  * 可选加密存储敏感数据
  * [Cookbook](docs/cookbook/readme.md)
  * app层面的message log和reply log
  * 完善单元测试
  * 后台表单验证

  * 命令行工具
  * 第三方平台接入
  * accesstoken开放给第三方并对接第三方accesstoken
  * 客服消息/对话
  * 清理及保护永久素材
  * 回复及一些查询缓存
  * 菜单及消息处理程序的导入导出
  * 素材Storage

  * 多次同步消息处理器会重复生成永久素材

  Xavier-Lam@NetDragon


pkgId: ec9fe9a04d05d98fc8b777efc61b4a53eb8422ac9c65c2603b17863ff8e0bbdd
name: python-weheat-help
arch: noarch
version: 2024.11.26
epoch: 0
release: 1
summary: Development documents and examples for weheat
url: https://github.com/wefabricate/wh-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-weheat-2024.11.26-1.src.rpm
location_href: Packages/python-weheat-help-2024.11.26-1.noarch.rpm
checksum_type: sha256
description:
  This is a client for the Weheat backend. It is automatically generated from the OpenAPI specification.



  Python 3.7+



  You can install directly using:

  ```sh
  pip install weheat
  ```

  Then import the package:

  ```python
  import weheat
  ```





  After installation, you can now use the client to interact with the Weheat backend.

  ```python
  import datetime
  from keycloak import KeycloakOpenID  # install with pip install python-keycloak
  from weheat import ApiClient, Configuration, HeatPumpApi, HeatPumpLogApi, EnergyLogApi


  auth_url = 'https://auth.weheat.nl/auth/'
  api_url = 'https://api.weheat.nl'
  realm_name = 'Weheat'
  my_client_id = 'WeheatCommunityAPI'  # client ID and secret provided by Weheat
  my_client_secret = ''
  username = ''  # username and password used for the online portal
  password = ''
  my_heat_pump_id = ''  # your heat pump UUID


  keycloak_open_id = KeycloakOpenID(server_url=auth_url,
                                    client_id=my_client_id,
                                    realm_name=realm_name,
                                    client_secret_key=my_client_secret)

  token_response = keycloak_open_id.token(username, password)
  keycloak_open_id.logout(token_response['refresh_token'])


  config = Configuration(host=api_url, access_token=token_response['access_token'])


  with ApiClient(configuration=config) as client:
      
      response = HeatPumpApi(client).api_v1_heat_pumps_get_with_http_info()

      if response.status_code == 200:
          print(f'My heat pump: {response.data}')

      
      response = HeatPumpLogApi(client).api_v1_heat_pumps_heat_pump_id_logs_latest_get_with_http_info(
          heat_pump_id=my_heat_pump_id)

      if response.status_code == 200:
          print(f'My heat pump logs: {response.data}')

      
      
      response = EnergyLogApi(client).api_v1_energy_logs_heat_pump_id_get_with_http_info(heat_pump_id=my_heat_pump_id,
                                                                                         start_time=datetime.datetime(
                                                                                             2024, 6,
                                                                                             22, 0, 0,
                                                                                             0),
                                                                                         end_time=datetime.datetime(2024,
                                                                                                                    6, 22,
                                                                                                                    15, 0,
                                                                                                                    0),
                                                                                         interval='Hour')

      if response.status_code == 200:
          print(f'My energy logs: {response.data}')


  ```


pkgId: 2354c283cb1998c4b54f53de32fc6e143121f0a62b59fdb5f98d73f9920217c3
name: python-whatsapp-chatbot-python-help
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: Development documents and examples for whatsapp-chatbot-python
url: https://github.com/green-api/whatsapp-chatbot-python
rpm_license: Creative Commons Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whatsapp-chatbot-python-0.9.4-1.src.rpm
location_href: Packages/python-whatsapp-chatbot-python-help-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/license-CC%20BY--ND%204.0-green)
  ![](https://img.shields.io/pypi/status/whatsapp-chatbot-python)
  ![](https://img.shields.io/pypi/pyversions/whatsapp-chatbot-python)
  ![](https://img.shields.io/github/actions/workflow/status/green-api/whatsapp-chatbot-python/python-package.yml)
  ![](https://img.shields.io/pypi/dm/whatsapp-chatbot-python)

  - [Документация на русском языке](https://github.com/green-api/whatsapp-chatbot-python/blob/master/docs/README.md).

  whatsapp-chatbot-python is a library for integration with WhatsApp messenger using the API
  service [green-api.com](https://green-api.com/en/). You should get a registration token and an account ID in
  your [personal cabinet](https://console.green-api.com/) to use the library. There is a free developer account tariff.



  The documentation for the REST API can be found at the [link](https://green-api.com/en/docs/). The library is a wrapper
  for the REST API, so the documentation at the link above also applies.



  To send a message or perform other Green API methods, the WhatsApp account in the phone app must be authorized. To
  authorize the account, go to your [cabinet](https://console.green-api.com/) and scan the QR code using the WhatsApp app.



  Installation:

  ```shell
  python -m pip install whatsapp-chatbot-python
  ```



  ```
  from whatsapp_chatbot_python import GreenAPIBot, Notification
  ```



  Before launching the bot, you should remove Webhook Url (if set) from Personal Cabinet or by setting empty webhookUrl by using [SetSettings method](https://green-api.com/en/docs/api/account/SetSettings/). These settings will be enabled by bot automatically:


  ```json
  {
    "incomingWebhook": "yes",
    "outgoingMessageWebhook": "yes",
    "outgoingAPIMessageWebhook": "yes"
  }
  ```





  ```
  bot = GreenAPIBot(
      "1101000001", "d75b3a66374942c5b3c019c698abc2067e151558acbd412345"
  )
  ```



  ```
  bot = GreenAPIBot(
      "1101000001", "d75b3a66374942c5b3c019c698abc2067e151558acbd412345",
      bot_debug_mode=True
  )
  ```

  You can also enable API debug mode:

  ```
  bot = GreenAPIBot(
      "1101000001", "d75b3a66374942c5b3c019c698abc2067e151558acbd412345",
      debug_mode=True, bot_debug_mode=True
  )
  ```



  To start receiving incoming notifications, you need to set up an instance. Open the personal cabinet page at
  the [link](https://console.green-api.com/). Select an instance from the list and click on it. Click **Change**. In the
  **Notifications** category, enable all notifications that you want to receive.



  To start receiving messages, you must create a handler function with one parameter (`notification`). The `notification`
  parameter is the class where the notification object (`event`) and the functions to answer the message are stored. To
  send a text message in response to a notification, you need to call the `notification.answer` function and pass there
  the text of the message. You don't need to pass the `chatId` parameter because it is automatically taken from the
  notification.

  Next, you need to add the handler function to the list of handlers. This can be done with the `bot.router.message`
  decorator as in the example or with the `bot.router.message.add_handler` function. The decorator must be called with
  brackets.

  To start the bot, call the `bot.run_forever` function. You can stop the bot with the key combination Ctrl + C.

  In this example, the bot will only answer the `message` message.

  Link to example: [base.py](https://github.com/green-api/whatsapp-chatbot-python/blob/master/examples/base.py).

  ```
  @bot.router.message(text_message="message")
  def message_handler(notification: Notification) -> None:
      notification.answer("Hello")


  bot.run_forever()
  ```



  You can receive not only incoming messages but also outgoing messages. You can also get the status of the sent message.

  - To receive outgoing messages, you need to use the `bot.router.outgoing_message` object;
  - To receive outgoing API messages, you need to use the `bot.router.outgoing_api_message` object;
  - To receive the status of sent messages, you need to use the `bot.router.outgoing_message_status` object.

  The body of the notification is in `notification.event`. In this example, we get the message type from the notification
  body.

  In this example, the bot receives all incoming messages.

  Link to example: [event.py](https://github.com/green-api/whatsapp-chatbot-python/blob/master/examples/event.py).

  ```
  @bot.router.message()
  def message_handler(notification: Notification) -> None:
      print(notification.event)


  bot.run_forever()
  ```



  Messages can be filtered by chat, sender, message type, and text. To filter chat, sender, and message type, you can use
  a string (`str`) or a list of strings (`list[str]`). The message text can be filtered by text, command, and regular
  expressions. Below is a table with filter names and possible values.

  | Filter name    | Description                                                                               | Possible values                                                    |
  |----------------|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
  | `from_chat`    | Chats or chats from which you want to receive messages                                    | `"11001234567@c.us"` or `["11001234567@c.us", "11002345678@c.us"]` |
  | `from_sender`  | The sender or senders from whom you want to receive messages                              | `"11001234567@c.us"` or `["11001234567@c.us", "11002345678@c.us"]` |
  | `type_message` | The type or types of message to be handled                                                | `"textMessage"` or `["textMessage", "extendedTextMessage"]`        |
  | `text_message` | Your function will be executed if the text fully matches the text                         | `"message"` or `["message", "MESSAGE"]`                            |
  | `regexp`       | Your function will be executed if the text matches the regular expression pattern         | `r"message"` or `(r"message", re.IGNORECASE)`                      |
  | `command`      | Your function will be executed if the prefix and the command match your values completely | `"help"` or `("help", "!/")`                                       |



  ```
  @bot.router.message(command="command")
  ```



  ```
  bot.router.message.add_handler(handler, command="command")
  ```



  To filter messages by chat, sender, or message type, you must add a string (`str`) or a list of strings (`list[str]`).

  ```
  from_chat = "11001234567@c.us"
  ```

  ```
  from_sender = "11001234567@c.us"
  ```

  ```
  type_message = ["textMessage", "extendedTextMessage"]
  ```



  You must add a string (`str`) to filter messages by text or regular expressions.

  ```
  text_message = "Hello. I need help."
  ```

  ```
  regexp = r"Hello. I need help."
  ```



  Add a string (`str`) or a tuple (`tuple`) to filter messages by command. You need to specify either a command name or a
  command name and a prefix string. The default prefix is `/`.

  ```
  command = "help"
  ```

  ```
  command = ("help", "!/")
  ```



  In this example, the bot will send a photo in response to the `rates` command.

  Link to example: [filters.py](https://github.com/green-api/whatsapp-chatbot-python/blob/master/examples/filters.py).

  ```
  @bot.router.message(command="rates")
  def message_handler(notification: Notification) -> None:
      notification.answer_with_file(file="data/rates.png")


  bot.run_forever()
  ```



  The method is temporarily not working. When the method is called, a 403 error will be returned.

  To be notified when a button is pressed, you must use the `bot.router.buttons` object.

  Link to example: [buttons.py](https://github.com/green-api/whatsapp-chatbot-python/blob/master/examples/buttons.py).

  ```
  @bot.router.buttons()
  def buttons_handler(notification: Notification) -> None:
      notification.answer_buttons("Choose a color", [
          {
              "buttonId": 1,
              "buttonText": "Red"
          },
          {
              "buttonId": 2,
              "buttonText": "Green"
          },
          {
              "buttonId": 3,
              "buttonText": "Blue"
          }
      ])


  bot.run_forever()
  ```



  As an example, a bot was created for user registration.

  To manage user states, we need to create states. Import the `BaseStates` class and inherit from it. To manage the state
  we need to use `notification.state_manager`. The manager has methods for getting, setting, updating and deleting state.
  You also have the option to save the user's data in his state.

  | Manager's method    | Description                                                                           |
  |---------------------|---------------------------------------------------------------------------------------|
  | `get_state`         | Returns a state class with state name and user data                                   |
  | `set_state`         | Sets the state for the user. If the state exists then the data will be deleted        |
  | `update_state`      | If a state exists, it changes it. If not, it creates a new state                      |
  | `delete_state`      | Deletes the user's state. Remember to get the data before deleting                    |
  | `get_state_data`    | If the state exists, it returns the data in the form of a dictionary (dict)           |
  | `set_state_data`    | If the state exists, it changes the data to the new data                              |
  | `update_state_data` | If the state exists, it updates the data. If no data exists, the data will be created |
  | `delete_state_data` | If the state exists, it deletes the data                                              |

  The first argument is the sender ID. It can be found by calling `notification.sender`.

  Link to example: [states.py](https://github.com/green-api/whatsapp-chatbot-python/blob/master/examples/states.py).

  ```python
  from whatsapp_chatbot_python import BaseStates, GreenAPIBot, Notification

  bot = GreenAPIBot(
      "1101000001", "d75b3a66374942c5b3c019c698abc2067e151558acbd412345"
  )


  class States(BaseStates):
      USERNAME = "username"
      PASSWORD = "password"


  @bot.router.message(state=None)
  def message_handler(notification: Notification) -> None:
      sender = notification.sender

      notification.state_manager.set_state(sender, States.USERNAME.value)

      notification.answer("Hello. Tell me your username.")


  @bot.router.message(command="cancel")
  def cancel_handler(notification: Notification) -> None:
      sender = notification.sender

      state = notification.state_manager.get_state(sender)
      if not state:
          return None
      else:
          notification.state_manager.delete_state(sender)

          notification.answer("Bye")


  @bot.router.message(state=States.USERNAME.value)
  def username_handler(notification: Notification) -> None:
      sender = notification.sender
      username = notification.message_text

      if not 5 <= len(username) <= 20:
          notification.answer("Invalid username.")
      else:
          notification.state_manager.update_state(sender, States.PASSWORD.value)
          notification.state_manager.set_state_data(
              sender, {"username": username}
          )

          notification.answer("Tell me your password.")


  @bot.router.message(state=States.PASSWORD.value)
  def password_handler(notification: Notification) -> None:
      sender = notification.sender
      password = notification.message_text

      if not 8 <= len(password) <= 20:
          notification.answer("Invalid password.")
      else:
          data = notification.state_manager.get_state_data(sender)

          username = data["username"]

          notification.answer(
              (
                  "Successful account creation.\n\n"
                  f"Your username: {username}.\n"
                  f"Your password: {password}."
              )
          )

          notification.state_manager.delete_state(sender)


  bot.run_forever()
  ```



  - How to call API methods?

  ```
  bot.api.account.getSettings()
  ```

  Or

  ```
  notification.api.account.getSettings()
  ```

  - How do I disable error raising?

  ```
  bot = GreenAPIBot(
      "1101000001", "d75b3a66374942c5b3c019c698abc2067e151558acbd412345",
      raise_errors=False
  )
  ```

  - How do I subscribe only to text messages?

  You need to import the required constants first:

  ```
  from whatsapp_chatbot_python.filters import TEXT_TYPES
  ```

  Then add this filter: `type_message=TEXT_TYPES`.

  - How do I get the message text and sender ID?

  This data is in the notification object (`notification`):

  ```
  @bot.router.message()
  def message_handler(notification: Notification) -> None:
      print(notification.sender)
      print(notification.message_text)
  ```



  As an example, a bot was created to support the GREEN API. Command list:

  - start (the bot says hello and sends a list of commands)
  - 1 or Report a problem (the bot will send a link to GitHub to create the bug)
  - 2 or Show office address (the bot will send the office address as a map)
  - 3 or Show available rates (the bot will send a picture of the rates)
  - 4 or Call a support operator (the bot will send a text message)

  To send a text message, you have to use the `notification.answer` method.
  To send a location, you have to use the `sending.sendLocation` method from `notification.api`.
  To send a message with a file, you have to use the `notification.answer_with_file` method.

  In this example, the bot only responds to commands from the list above.

  Link to example: [full.py](https://github.com/green-api/whatsapp-chatbot-python/blob/master/examples/full.py).

  ```python
  from whatsapp_chatbot_python import GreenAPIBot, Notification

  bot = GreenAPIBot(
      "1101000001", "d75b3a66374942c5b3c019c698abc2067e151558acbd412345"
  )


  @bot.router.message(command="start")
  def message_handler(notification: Notification) -> None:
      sender_data = notification.event["senderData"]
      sender_name = sender_data["senderName"]

      notification.answer(
          (
              f"Hello, {sender_name}. Here's what I can do:\n\n"
              "1. Report a problem\n"
              "2. Show office address\n"
              "3. Show available rates\n"
              "4. Call a support operator\n\n"
              "Choose a number and send to me."
          )
      )


  @bot.router.message(text_message=["1", "Report a problem"])
  def report_problem_handler(notification: Notification) -> None:
      notification.answer(
          "https://github.com/green-api/issues/issues/new", link_preview=False
      )


  @bot.router.message(text_message=["2", "Show office address"])
  def show_office_address_handler(notification: Notification) -> None:
      chat = notification.chat

      notification.api.sending.sendLocation(
          chatId=chat, latitude=55.7522200, longitude=37.6155600
      )


  @bot.router.message(text_message=["3", "Show available rates"])
  def show_available_rates_handler(notification: Notification) -> None:
      notification.answer_with_file("data/rates.png")


  @bot.router.message(text_message=["4", "Call a support operator"])
  def call_support_operator_handler(notification: Notification) -> None:
      notification.answer("Good. A tech support operator will contact you soon.")


  bot.run_forever()
  ```



  [Service methods documentation](https://green-api.com/en/docs/api/)



  Licensed under [
  Creative Commons Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0)
  ](https://creativecommons.org/licenses/by-nd/4.0/) terms. Please see file [LICENSE](
  https://github.com/green-api/whatsapp-chatbot-python/blob/master/LICENSE
  ).


pkgId: 07d7222fa1c64443f126b4ce88bbd5fd47594a84f8aa4621479246c757344e6f
name: python-whatthepatch-pydantic-help
arch: noarch
version: 1.0.6a3
epoch: 0
release: 1
summary: Development documents and examples for whatthepatch-pydantic
url: https://github.com/jingfelix/whatthepatch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whatthepatch-pydantic-1.0.6a3-1.src.rpm
location_href: Packages/python-whatthepatch-pydantic-help-1.0.6a3-1.noarch.rpm
checksum_type: sha256
description:
  **Note that this is a fork of [whatthepatch](https://github.com/cscorley/whatthepatch) and aims to add pydantic support**
  What The Patch!? is a library for both parsing and applying patch files.


pkgId: 73ac8ebe373f81be1c0b659b656b40f889504f4d0531de7f3bb574552e205f35
name: python-whetstone-ml-help
arch: noarch
version: 0.1.0.dev15
epoch: 0
release: 1
summary: Development documents and examples for whetstone-ml
url: https://github.com/dkhundley/whetstone-ml
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whetstone-ml-0.1.0.dev15-1.src.rpm
location_href: Packages/python-whetstone-ml-help-0.1.0.dev15-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="docs/assets/images/whetstone-ml-logo.png" width="400"><br>
  </div>








  The name for this library is inspired by the [real life stone object](https://en.wikipedia.org/wiki/Sharpening_stone) designed to keep knives sharp. When a knife becomes dull, a whetstone is used to revitalize its sharpness so that the knife may continue to be used in an optimal manner. Because data tends to drift over time, machine learning (ML) models running in a production environment may experience degradation in the form of model drift. Like a whetstone helps to keep knives sharp, Whetstone ML is a free, open-source Python library designed to assist data science practitioners with validating that ML models running in a production environment continue to perform at an optimal level.

rpm_license:
  Apache License  Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024, David Hundley  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: 5ad67113ef71ea3c0984a84e932736d2109f12f868411cfbfc942701a53ca6fd
name: python-whiscraper-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for whiscraper
url: https://pypi.org/project/whiscraper/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whiscraper-0.2.0-1.src.rpm
location_href: Packages/python-whiscraper-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Invisible Execution**: Avoid detection by anti-bot systems.
  - **Lightweight**: Minimal setup, maximum performance.


pkgId: eb95eb62754b67ff4425f283084bc4a1605af4acd95814375030198aabbb84f7
name: python-whist-backend-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for whist-backend
url: https://pypi.org/project/whist-backend/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whist-backend-0.2.3-1.src.rpm
location_href: Packages/python-whist-backend-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Lint](https://github.com/Danie-1/whist_backend/actions/workflows/lint.yml/badge.svg)](https://github.com/Danie-1/whist_backend/actions/workflows/lint.yml)
  [![Tests](https://github.com/Danie-1/whist_backend/actions/workflows/tests.yml/badge.svg)](https://github.com/Danie-1/whist_backend/actions/workflows/tests.yml)
  [![Documentation Status](https://readthedocs.org/projects/whist-backend/badge/?version=latest)](https://whist-backend.readthedocs.io/en/latest/?badge=latest)
  [![PyPI Version](https://img.shields.io/pypi/v/whist_backend.svg)](https://pypi.python.org/pypi/whist_backend)

  To install, run
  ```
  pip install whist-backend
  ```



  See the `examples` folder of this repository for example usage, or view the
  [Example page in the documentation](https://whist-backend.readthedocs.io/en/latest/example.html).


pkgId: 526ec5e4484bc8b6dffd8726f83c61995bccf9d3cd5a407be269d55270e5958c
name: python-whitebox-plugin-device-insta360-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for whitebox-plugin-device-insta360
url: https://pypi.org/project/whitebox-plugin-device-insta360/
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whitebox-plugin-device-insta360-0.1.4-1.src.rpm
location_href: Packages/python-whitebox-plugin-device-insta360-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  This is a plugin for [whitebox](https://gitlab.com/whitebox-aero) that enables support for Insta360 cameras
  using the [insta360 library](https://gitlab.com/whitebox-aero/insta360).



  Simply install the plugin to whitebox:

  ```
  poetry add whitebox-plugin-device-insta360
  ```



  1. Set up whitebox locally.
  2. Clone this repository.
  3. Add plugin to whitebox using the following command: `poetry add -e path/to/plugin.`
  4. Run the whitebox server.



  1. Ensure you have the plugin installed in whitebox like mentioned above.
  2. Run the tests: `make test`.



  1. Write tests for each new feature.
  2. Ensure coverage is 90% or more.
  3. [Google style docstrings](https://mkdocstrings.github.io/griffe/docstrings/#google-style)
     should be used for all functions and classes.


pkgId: 52dfa49deec07dd5f2c1a4941781e1acccf4d691005910bdb180c2d4f1e1b17a
name: python-whiteduck-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for whiteduck
url: https://pypi.org/project/whiteduck/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whiteduck-0.5.0-1.src.rpm
location_href: Packages/python-whiteduck-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  A command-line tool for quickly creating new projects from templates. Automatically discovers and provides commands for all templates in the templates directory.



  ```bash

  git clone https://github.com/whiteduck-dev/project-starter.git
  cd project-starter


  uv build
  uv pip install -e .
  ```



  Install `uv`

  Visit the official documentation for detailed installation instructions:
  - [UV Installation Guide](https://docs.astral.sh/uv/)
  - [UV GitHub Repository](https://github.com/astral-sh/uv)

  List available templates:
  ```bash
  uvx whiteduck --help
  ```

  Create a new project:
  ```bash

  uvx whiteduck react


  uvx whiteduck react -o my-project
  ```

  Get help for a specific template:
  ```bash
  uvx whiteduck react --help
  ```



  - **react** - A modern React project template with:
    - TypeScript support
    - Vite for fast development
    - TailwindCSS for styling
    - Shadcn/ui components
    - Python backend structure

  - **lib** - A template for creating Python libraries
    - Modern Python package structure
    - Testing setup
    - Documentation scaffolding

  - **package** - A template for Python packages
    - Basic package structure
    - Development tools configuration
    - Distribution setup



  1. Create a new directory under `src/whiteduck/templates/`
  2. Name the directory what you want the command to be (e.g., `api` for `whiteduck api`)
  3. Add your template files to this directory
  4. The command will be automatically available - no code changes needed

  For example:
  ```bash

  mkdir src/whiteduck/templates/api


  cp -r my-api-files/* src/whiteduck/templates/api/


  uv run whiteduck api --help
  ```



  - Website: [https://www.whiteduck.de](https://www.whiteduck.de)
  - Version: 0.1.0



  Copyright © 2024 white duck GmbH. All rights reserved.


pkgId: 58238bdfdca5b675f3611da55b2072cf62e1442311d451e2b44b0b3275df570f
name: python-whylogs-container-client-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for whylogs-container-client
url: https://pypi.org/project/whylogs-container-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-whylogs-container-client-2.3.0-1.src.rpm
location_href: Packages/python-whylogs-container-client-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  A client library for accessing FastAPI.

  See the [WhyLabs doc site](https://docs.whylabs.ai/docs/integrations-whylogs-container) for full documentation, or see the [API
  endpoint](https://whylabs.github.io/whylogs-container-python-docs/whylogs-container-python.html#operation/log_docs_log_docs_post)
  documentation for information on a specific API. The structure there mimics the module structure in the generated client.



  First, create a client:

  ```python
  from whylogs_container_client import AuthenticatedClient



  client = AuthenticatedClient(base_url="http://localhost:8000", token="password", prefix="", auth_header_name="X-API-Key")

  from whylogs_container_client import Client


  client = Client(base_url="http://localhost:8000")
  ```



  Things to know:

  1. Every API has four ways of calling it.

     1. `sync`: Blocking request that returns parsed data (if successful) or `None`
     1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
     1. `asyncio`: Like `sync` but async instead of blocking
     1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking

  1. APIs are grouped by their "tags" as Python modules.
  1. APIs that do not have a tag are in `whylogs_container_client.api.default`

  Here are some example requests for common APIs.



  ```python
  from datetime import datetime

  import whylogs_container_client.api.profile.log as Log
  from whylogs_container_client.models import LogMultiple, LogRequest


  time_ms = int(datetime.now().timestamp() * 1000)

  data = LogRequest(
      dataset_id="model-141",
      timestamp=time_ms,
      multiple=LogMultiple(
          columns=["custom_metric_1", "custom_metric_2"],
          data=[[1, 2], [3, 4]],
      ),
  )

  response = Log.sync_detailed(client=client, body=data)
  if response.status_code != 200:
      raise Exception(f"Failed to log data. Status code: {response.status_code}")
  ```



  ```python
  from whylogs_container_client.models.evaluation_result import EvaluationResult
  from whylogs_container_client.models.llm_validate_request import LLMValidateRequest
  from whylogs_container_client.models.validation_result import ValidationResult

  request = LLMValidateRequest(
      prompt="?",
      response="I'm sorry you feel that way.",
      dataset_id="model-139",
      id="myid",
  )

  response = Evaluate.sync_detailed(client=client, body=request)

  if not isinstance(response.parsed, EvaluationResult):
      raise Exception(f"Failed to validate data. Status code: {response.status_code}. {response.parsed}")

  result: ValidationResult = response.parsed.validation_results
  ```



  ```python
  import whylogs_container_client.api.manage.health as Health

  response = Health.sync_detailed(client=client)

  if not response.status_code == 200:
      raise Exception(f"Failed health check. Status code: {response.status_code}. {response.parsed}")
  ```



  ```python
  import whylogs_container_client.api.manage.status as Status
  from whylogs_container_client.models.status_response import StatusResponse

  response = Status.sync_detailed(client=client)

  if response.parsed is None:
      raise Exception("Unexpected response type")

  result: StatusResponse = response.parsed
  ```



  You can customize or disable the certificate verification.

  ```python

  client.verify_ssl = "/path/to/certificate_bundle.pem"
  ```

  ```python

  def log_request(request):
      print(f"Request event hook: {request.method} {request.url} - Waiting for response")

  def log_response(response):
      request = response.request
      print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")

  client.httpx_args = {"event_hooks": {"request": [log_request], "response": [log_response]}}
  ```



  You can set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):

  ```python
  import httpx
  from whylogs_container_client import Client

  client = Client(
      base_url="https://api.example.com",
  )

  client.set_httpx_client(httpx.Client(base_url="https://api.example.com", proxies="http://localhost:8030"))
  ```


pkgId: 2e4a7be0ceb99da5a82e78f45b326762bc109b10a72bccea5d759c7b763081e7
name: python-wide-analysis-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for wide-analysis
url: https://github.com/hsuvas/wide_analysis
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wide-analysis-1.0-1.src.rpm
location_href: Packages/python-wide-analysis-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  Wide-Analysis is a suite of tools for analyzing Wikipedia deletion discussions. It is designed to help researchers and practitioners to understand the dynamics of deletion discussions, and to develop tools for supporting the decision-making process in Wikipedia. The suite includes a set of tools for collecting, processing, and analyzing deletion discussions. The package contains the following functionalities
  - **Data Collection and preprcoessing**: Collecting deletion discussions from Wikipedia and prepare a dataset. This can be done in article title level, or in date-range level.
  - **Model based functionalities**: The suite includes a set of Language Model based tasks, such as:
      - **Outcome Prediction**: Predicting the outcome of a deletion discussion, the outcome can be the decision made with the discussion (e.g., keep, delete, merge, etc.) (determined from the complete discussion)
      - **Stance Detection**: Identifying the stance of the participants in the discussion, in relation to the deletion decision.(determined from each individual comment in discussion)
      - **Policy Prediction**: Predicting the policy that is most relevant to the comments of the participants in the discussion.(determined from each individual comment in discussion)
      - **Sentiment Prediction**: Predicting the sentiment of the participants in the discussion, in relation to the deletion decision.(determined from each individual comment in discussion)
      - **Offensive Language Detection**: Detecting offensive language in the comments of the participants in the discussion.(determined from each individual comment in discussion)




  You can install the package from PyPI using the following command:

  ```pip install wide-analysis```

  After the installation, you can import the package and start using the functionalities.





  The dataset creation funtionalities will return a dataframe. The data collection command contains the following parameters:
  - mode : str
      - The mode of data collection. It can be 'article', 'date_range', or 'date' or 'existing'.
  - start_date : str
      - The start date of the data collection. It should be in the format 'YYYY-MM-DD'(for example, '2021-01-01').
  - end_date : str
      - The end date of the data collection. It should be in the format 'YYYY-MM-DD'(for example, '2021-01-01'). If left empty, the data collection will be done for a single date(start_date).
  - url : str (optional)
      - The URL of the Wikipedia deletion discussion log page. Only needed for title based extraction. for example: https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2021_January_1
  - title : str
      - The title of the Wikipedia article. only needed for title based extraction. for example: 'COVID-19_pandemic_in_India'
  - output_path : str
      - The path to save the dataset.The dataset will be saved as 'csv' file. If not provided, the dataset will be returned as a dataframe.


  Creation of dataset can be done in four ways:

  - **Wide-analysis Dataset**: If selected 'wide_2023' as mode parameter, then the data will be collected from the existing Wide-analysis dataset available in huggingface('hsuvaskakoty/wide_analysis') and the function will return huggingface dataset.

  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'wide_2023',
                              start_date=None,
                              end_date=None,
                              url=None,
                              title=None,
                              output_path=None)
  ```

  Example:
  To collect the existing 'wide_2023' dataset, the following command can be used:

  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'wide_2023',
                              start_date=None,
                              end_date=None,
                              url=None,
                              title=None,
                              output_path=None)
  ```
  will return the existing dataset available in huggingface('hsuvaskakoty/wide_analysis').

  ```python
  Datset loaded successfully as huggingfaece dataset
  The dataset has the following columns: {'train': ['text', 'label'], 'validation': ['text', 'label'], 'test': ['text', 'label']}
  ```

  - **Article level**: Collecting deletion discussions for a specific article.
  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'title',
                              start_date='YYYY-MM-DD',
                              end_date=None,
                              url='URL for the title',
                              title='article title',
                              output_path='save_path' or None)
  ```

  Example:
  To collect the deletion discussions for the article 'Raisul Islam Ador' for the date '2024-07-18', the following command can be used:

  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'title',
                              start_date='2024-07-18',
                              end_date=None,
                              url='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',
                              title='Raisul Islam Ador',
                              output_path= None)
  ```
  This will return a dataframe with the data for the title 'Raisul Islam Ador' for the date '2024-07-18'. If the output_path is provided, the dataframe will be saved as a csv file in the provided path. The output looks like the following:

  | Date       | Title               | URL                | Discussion             | Label         | Confirmation                  |
  |------------|---------------------|--------------------|------------------------|---------------|-------------------------------|
  | 2024-07-18 | Raisul Islam Ador   | [URL to article text](https://en.wikipedia.org/w/index.php?title=Raisul_Islam_Ador&action=edit&redlink=1) | Deletion discussion here | speedy delete | Please do not modify it.      |



  - **Date range level**: Collecting deletion discussions for a specific date range.
  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'date_range',
                              start_date='YYYY-MM-DD',
                              end_date='YYYY-MM-DD',
                              url=None,
                              title=None,
                              output_path='save_path' or None)
  ```
  Example:
  To collect the deletion discussions for the articles within the date range '2024-07-18' and '2024-07-20', the following command can be used:

  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'date_range',
                              start_date='2024-07-18',
                              end_date='2024-07-20',
                              url=None,
                              title=None,
                              output_path= None)
  ```

  This will return a dataframe with the data for the articles within the date range '2024-07-18' and '2024-07-20'. The output looks like the same format as the article level data collection, just with more rows for each date within the date range.


  - **Date level**: Collecting deletion discussions for a specific date.
  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'date',
                              start_date='YYYY-MM-DD',
                              end_date=None,
                              url=None,
                              title=None,
                              output_path= None)
  ```

  Example:
  To collect the deletion discussions for the articles within the date '2024-07-18', the following command can be used:

  ```python
  from wide_analysis import data_collect
  data = data_collect.collect(mode = 'date',
                              start_date='2024-07-18',
                              end_date=None,
                              url=None,
                              title=None,
                              output_path= None)
  ```

  This will return a dataframe with the data for the articles within the date '2024-07-18'. The output looks like the same format as the article level data collection, just with more rows for each article within the date.




  We train a set of models and leverage some pretrained task based models from huggingface for the following tasks: Outcome Prediction, Stance Detection, Policy Prediction, Sentiment Prediction, and Offensive Language Detection. The functionalities will return a dictionary, with the predictions for each task and their individual probablity score. The model based functionalities contain the following parameters:

  - inp: 'str'
      - The url or text of the Wikipedia article deletion discussion.
  - mode: 'str'
      - The mode of the input. it can be 'url' or 'text'. If 'url' is selected, the input should be the URL of the Wikipedia article deletion discussion. If 'text' is selected, the input should be the text of the Wikipedia article deletion discussion in the following format: _Title: Deletion discussion Text_ where Title is the title of the article and Text is the deletion discussion. Default is 'url'.
  - task: 'str'
      - The task to be performed. It can be 'outcome', 'stance', 'policy', 'sentiment', or 'offensive'.

  It is worth noting that the model based functionalities are only available for the article level data collection. We also provide an explanation feature for _outcome prediction_ task, which will return the explanation of the prediction made by the model using Openai GPT 3.5 model. You will need your own API key for this feature to work.



  Apart from the input parameters, the outcome prediction function also contains the following parameters:

  - openai_access_token: 'str'
      - The API key for Openai GPT 4o-mini model. If explanation is True, then it will ask for the API key for Openai GPT 4o-mini model. Default is None.
  - explanation: 'bool'
      - If True, it will return the explanation of the prediction made by the model. Default is False.

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='URL/text of the article',
                      mode='url or text',
                       task='outcome',
                       openai_access_token=None,
                       explanation=False)
  ```
  <!-- This will trigger a set of questions :
  - Do you want an explanation?(True/False): If True, it will return the explanation of the prediction made by the model.
  - If explanation is True, then it will ask for the API key for Openai GPT 3.5 model. -->

  Example:
  To predict the outcome of the deletion discussion for the article 'Raisul Islam Ador' using discussion url, the following command can be used:

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',
                  mode= 'url',
                  task='outcome',
                  openai_access_token=None,
                  explanation=False)
  ```
  OR if using text:

  ```python
  from wide_analysis import analyze
  text_input = 'Raisul Islam Ador: None establish his Wikipedia:Notability. The first reference is almost identical in wording to his official web site.CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.' #sample input text
  predictions = analyze(inp=text_input,
                      mode= 'text',
                      task='outcome',
                      openai_access_token=None,
                      explanation=False)
  ```

  Both of which will return the following output:
  ```python
  {'prediction': 'speedy delete', 'probability': 0.99}
  ```

  To predict the outcome of the deletion discussion for the article 'Raisul Islam Ador' with explanation, the following command can be used:

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',
                      mode='url',
                      task='outcome',
                      openai_access_token='<OPENAI KEY>',
                      explanation=True)
  ```
  <!-- Then the following questions will be asked:

  ```python
  Do you want an explanation?(True/False): True
  Please enter your API key for Openai GPT: <OPENAI KEY>
  ``` -->

  Returns:
  ```python
  {'prediction': 'speedy delete',
  'probability': 0.99,
  'explanation': 'The article does not establish the notability of the subject. The references are not reliable and the article is not well written. '}
  ```



  ```python
  from wide_analysis import analyze
  predictions = analyze.analyze(inp='URL/text of the article',mode='url or text', task='stance')
  ```

  Example:
  To predict the stance of the participants in the deletion discussion for the article 'Raisul Islam Ador', the following command can be used:

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',mode = 'url', task='stance')
  ```

  OR if using text:

  ```python
  from wide_analysis import analyze
  text_input = 'Raisul Islam Ador: None establish his Wikipedia:Notability. The first reference is almost identical in wording to his official web site.CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.' #sample input text
  predictions = analyze(inp=text_input, mode= 'text', task='stance')
  ```

  Both of which will return the following output:
  ```python
  [{'sentence': 'None establish his Wikipedia:Notability .  ', 'stance': 'delete', 'score': 0.9950249791145325},
  {'sentence': 'The first reference is almost identical in wording to his official web site.  ', 'stance': 'delete', 'score': 0.7702090740203857},
  {'sentence': 'CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.  ', 'stance': 'delete', 'score': 0.9993199110031128}]
  ```



  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='URL/text of the article',mode='url or text', task='policy')
  ```

  Example:
  To predict the policy that is most relevant to the comments of the participants in the deletion discussion for the article 'Raisul Islam Ador', the following command can be used:

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',mode = 'url', task='policy')
  ```
  OR if using text:

  ```python
  from wide_analysis import analyze
  text_input = 'Raisul Islam Ador: None establish his Wikipedia:Notability. The first reference is almost identical in wording to his official web site.CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.' #sample input text
  predictions = analyze(inp=text_input, mode= 'text', task='policy')
  ```

  Both of which will return the following output:
  ```python
  [{'sentence': 'None establish his Wikipedia:Notability .  ', 'policy': 'Wikipedia:Notability', 'score': 0.8100407719612122},
  {'sentence': 'The first reference is almost identical in wording to his official web site.  ', 'policy': 'Wikipedia:Notability', 'score': 0.6429345607757568},
  {'sentence': 'CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.  ', 'policy': 'Wikipedia:Criteria for speedy deletion', 'score': 0.9400111436843872}]
  ```



  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='URL/text of the article',mode='url or text', task='sentiment')
  ```

  Example:
  To predict the sentiment of the participants in the deletion discussion for the article 'Raisul Islam Ador' with url, the following command can be used:

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',mode='url' task='sentiment')
  ```
  OR if using text:

  ```python
  from wide_analysis import analyze
  text_input = 'Raisul Islam Ador: None establish his Wikipedia:Notability. The first reference is almost identical in wording to his official web site.CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.' #sample input text
  predictions = analyze(inp=text_input, mode= 'text', task='sentiment')
  ```

  Both of which will return the following output:
  ```python
  [{'sentence': 'None establish his Wikipedia:Notability .  ', 'sentiment': 'negative', 'score': 0.515991747379303},
   {'sentence': 'The first reference is almost identical in wording to his official web site.  ', 'sentiment': 'neutral', 'score': 0.9082792401313782},
   {'sentence': 'CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.  ', 'sentiment': 'neutral', 'score': 0.8958092927932739}, ]
  ```



  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='URL/text of the article',mode='url or text', task='offensive')
  ```

  Example:
  To detect offensive language in the comments of the participants in the deletion discussion for the article 'Raisul Islam Ador', the following command can be used:

  ```python
  from wide_analysis import analyze
  predictions = analyze(inp='https://en.wikipedia.org/wiki/Wikipedia:Articles_for_deletion/Log/2024_July_15#Raisul_Islam_Ador',mode='url', task='offensive')
  ```
  OR if using text:

  ```python
  from wide_analysis import analyze
  text_input = 'Raisul Islam Ador: None establish his Wikipedia:Notability. The first reference is almost identical in wording to his official web site.CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.' #sample input text
  predictions = analyze(inp=text_input, mode= 'text', task='offensive')
  ```

  Both of which will return the following output:
  ```python
  [{'sentence': 'None establish his Wikipedia:Notability .  ', 'offensive_label': 'non-offensive', 'score': 0.8752073645591736},
  {'sentence': 'The first reference is almost identical in wording to his official web site.  ', 'offensive_label': 'non-offensive', 'score': 0.9004920721054077},
  {'sentence': 'CambridgeBayWeather (solidly non-human), Uqaqtuq (talk) , Huliva 20:06, 15 July 2024 (UTC) [ reply ] Delete , if not a CSD under G11.  ', 'offensive_label': 'non-offensive', 'score': 0.9054554104804993}]
  ```


pkgId: 37c8604154d46088436f9d4de4efbe7bffe586523bf047afbcd675bd079d8805
name: python-widget-state-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for widget-state
url: https://github.com/pLeminoq/widget_state
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-widget-state-0.0.5-1.src.rpm
location_href: Packages/python-widget-state-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  A small library of reactive wrappers (states) around values.
  Its main purpose is to be used in GUI applications where there is a visualization that depends on a state, which is updated on state changes.
  It draws some inspiration from my work with Vue and Flutter.


pkgId: 5c71cde8264abe0f767f3f1302999f93122e3c7369838164d487777b6dd3d4d0
name: python-wiever-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for wiever
url: https://github.com/python-poetry/poetry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wiever-0.1.1-1.src.rpm
location_href: Packages/python-wiever-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  > [!WARNING]
  > This project is under heavy development and is not ready for use yet.

  Wiever is a powerful and flexible CLI tool designed to provide detailed and customizable views of your directory structure. Whether you're looking to visualize your filesystem as a tree, generate detailed file listings, or explore other innovative views of your directories, Wiever has you covered.


  ```bash
  pip install wiever
  ```



  Contributions are welcome! To contribute:
  1. Fork the repository.
  2. Add new features or fix bugs.
  3. Submit a pull request.



  This project is licensed under the [MIT License](LICENSE).


pkgId: 47880316d99c269f9d5b5563e38f9e40f7265f50abe15cee44e4c31cfd915004
name: python-wikibasemigrator-help
arch: noarch
version: 0.0.15
epoch: 0
release: 1
summary: Development documents and examples for wikibasemigrator
url: https://pypi.org/project/wikibasemigrator/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wikibasemigrator-0.0.15-1.src.rpm
location_href: Packages/python-wikibasemigrator-help-0.0.15-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/wikibasemigrator)](https://pypi.python.org/pypi/wikibasemigrator)
  [![image](https://img.shields.io/pypi/pyversions/wikibasemigrator.svg)](https://pypi.python.org/pypi/wikibasemigrator)
  [![GitHub License](https://img.shields.io/github/license/tholzheim/WikibaseMigrator)](https://github.com/tholzheim/WikibaseMigrator/blob/master/LICENSE)
  [![GitHub issues](https://img.shields.io/github/issues/tholzheim/WikibaseMigrator?color=blue)](https://github.com/tholzheim/WikibaseMigrator/issues)
  [![Actions status](https://github.com/tholzheim/WikibaseMigrator/actions/workflows/CI.yml/badge.svg)](https://github.com/tholzheim/WikibaseMigrator/actions)
  [![Docker Pulls](https://img.shields.io/docker/pulls/tholzheim/wbmigrator)](https://hub.docker.com/r/tholzheim/wbmigrator)


  WikibaseMigrator is a tool to migrate wikibase entities from one wikibase instance to another.
  During the migration process all used Item and Property IDs are mapped to the IDs from the target Wikibase instance.



  ```shell
  pip install wikibasemigrator
  ```



  Install WikibaseMigrator after cloning with
  ```shell
  pip install .
  ```
  for development with
  ```shell
  pip install .[test]
  ```


  * WikibaseMigrator offers a cli tool and a web UI.
  * Migration is defined with a migration profile which needs to be defined. For details on the definition see [Wikibase Migration Profile Configuration](./docs/migration_profile_config.md)



  ```commandline
  docker run  -p 8009:8080 -v ~/.config/WikibaseMigrator/profiles/WikibaseMigrationTest.yaml:/config.yaml tholzheim/wbmigrator
  ```

  > Exchange `~/.config/WikibaseMigrator/profiles/WikibaseMigrationTest.yaml` with the location of your migration profile configuration if needed


  The webserver can be started over the cli with
  ```shell
   wbmigrate webserver --config FactGrid.yaml --host localhost --port 9100
  ```
  or with docker



  After installing the project cli is available under the name `ẁbmigrate`
  ```shell
  wbmigrate --help
  ```
  ```commandline
   Usage: wbmigrate [OPTIONS] COMMAND [ARGS]...

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ --install-completion          Install completion for the current shell.                                    │
  │ --show-completion             Show completion for the current shell, to copy it or customize the           │
  │                               installation.                                                                │
  │ --help                        Show this message and exit.                                                  │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ Commands ─────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ app         Run the WikibaseMigrator web server as local app Note: Experimental feature as some of the     │
  │             imported resources are not localized yet                                                       │
  │ webserver   Start the WikibaseMigrator web server                                                          │
  │ migrate     Migrate the provided entities                                                                  │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────╯


  ```


  ```shell
  wbmigrate migrate --help
  ```
  ```commandline
   Usage: wbmigrate migrate [OPTIONS]

   Migrate the provided entities

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ *  --config                               TEXT  The configuration file defining the Wikibases              │
  │                                                 [default: None]                                            │
  │                                                 [required]                                                 │
  │ *  --summary                              TEXT  Summary message to add to the wikibase edits               │
  │                                                 [default: None]                                            │
  │                                                 [required]                                                 │
  │    --entity                               TEXT  The items to migrate [default: None]                       │
  │    --query                                TEXT  The query querying the items to migrate. The items to      │
  │                                                 migrate must have the binding ?items                       │
  │                                                 [default: None]                                            │
  │    --query-file                           TEXT  The query file with a query querying the items to migrate. │
  │                                                 The items to migrate must have the binding ?item           │
  │                                                 [default: None]                                            │
  │    --show-details    --no-show-details          Show detailed information during the migration process     │
  │                                                 [default: no-show-details]                                 │
  │    --force           --no-force                 If True migrate items directly to target wikibase          │
  │                                                 [default: no-force]                                        │
  │    --help                                       Show this message and exit.                                │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────╯


  ```



  ```shell
  wbmigrate webserver --help
  ```
  ```commandline
   Usage: wbmigrate webserver [OPTIONS]

   Start the WikibaseMigrator web server

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ *  --config        TEXT     The configuration file defining the Wikibases [default: None] [required]       │
  │    --host          TEXT     host of the webserver [default: 0.0.0.0]                                       │
  │    --port          INTEGER  port of the webserver [default: 8080]                                          │
  │    --help                   Show this message and exit.                                                    │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```


  ```mermaid
  flowchart TD
      source[(source Wikibase)]
      target[(target Wikibase)]
      config@{ shape: doc, label: "Mapping Profile" }
      A@{ shape: circle, label: "Start" }
      A-- provide --> B(Entity IDs)
      B--start-->t
      config-->t
      q1<-.query.->target
          q3<-.query.->target
      subgraph Migrate
      subgraph Translation
              direction LR
              t@{ shape: sm-circ, label: "Small start" }
              t-->q1
              q1[[query mappings]]
              t-->q2[[query entity records]]
              ser@{ shape: docs, label: "Source Entity Records"}
              q2--result-->ser
              map@{ shape: doc, label: "Mapping Table" }
              q1--result-->map
              translate[translate]
              map-->translate
              ser-->translate
              translate-->TranslationResults@{ shape: docs, label: "Translated Entities"}


          end
          ex{exists<br>in target?}
          TranslationResults --> ex
          ex --noo-->TranslationResultsFinal
          ex --yes-->m
          TranslationResultsFinal@{ shape: docs, label: "Translated & Merged Entities"}
          mergedEntities-->TranslationResultsFinal

          subgraph merge
                  m@{ shape: sm-circ, label: "Small start" }
                  q3[[query entity records]]
                  m-->q3
                  targetEntities@{ shape: docs, label: "Target Entities"}
                  translatedEntities@{ shape: docs, label: "Translated Entities"}
                  q3--result-->targetEntities
                  m-->translatedEntities
                  merger[merge]
                  translatedEntities-->merger
                  targetEntities-->merger
                  mergedEntities@{ shape: docs, label: "Merged Entities"}
                  merger-->mergedEntities
              end
          migrator[migrate]
      end
      q2<-.query.->source
      TranslationResultsFinal-->migrator
      migrator --write--> target
      stop@{ shape: framed-circle, label: "Stop" }
      migrator-->stop
  ```

  If an entity already exists in the target wikibase instance the source entity is first translated to the target and then merged with the target entity.
  The merging of entities differs from the default wikibase entity merging for cases where the statement does not have qualifiers. In this case if the statement value is equal the qualifiers of the source are merged into the target.
  Otherwise, the merge results in an additional statement to preserve both qualifier information (equal to the wikibase entity merge)






  This project was funded by [FactGrid](https://database.factgrid.de)



  This repository is licensed under the [Apache 2.0](./LICENSE)


pkgId: 257e12ecf0149c522c104f935d5b21a3ede239421b27dfc390c413999e5ae917
name: python-wild-blue-yonder-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for wild-blue-yonder
url: https://github.com/wild-blue-yonder/wild-blue-yonder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wild-blue-yonder-0.0.2-1.src.rpm
location_href: Packages/python-wild-blue-yonder-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Package Name
  <pre>
    pip install wild-blue-yonder
  </pre>
  Then:
  ```Python
    
    import wild_blue_yonder
  ```


pkgId: b2c18d40aa2124eb08841aa92ab25fe37c293b10bb82a8cb7f4ce1f253f54e24
name: python-wiliot-testers-help
arch: noarch
version: 5.7.1
epoch: 0
release: 1
summary: Development documents and examples for wiliot-testers
url: https://pypi.org/project/wiliot-testers/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wiliot-testers-5.7.1-1.src.rpm
location_href: Packages/python-wiliot-testers-help-5.7.1-1.noarch.rpm
checksum_type: sha256
description:
  * added support for python 3.12
  * updated GUIs inlay
  * move test+equipwmwnt and sensors_and_hardware files to wiliot-tools package
  * added script to convert gateway gui output to offlines logs to enable data uploading and post-process results
  * Tester  SDK:
      * added the option to send gw commands for the entire test
      * added the option to get the gw signals responses based on gpio interface
      * bug fix when power is not specified on the specified test suite
      * added support to tag trasnmitting with zero advertising address
  * Offline Testers:
      * cleanup and improvements
      * Added tag reel location on the main gui
      * bug fix for enabling ignore-stop-criteri option
      * bug fix for bad crc counter on NO-RESPONSES locations
      * added support for extract new reel id for SGTIN, for GEN3 tags
      * added pop up message if batch name was invalid
      * added support for bi-directional printing
      * printing offset alue convestion was changed
      * added the conversation label code to the offline for gen3 tags
      * added environement setup script for first installations and release update
  * Sample Test:
      * added stop citeria for number of packet and/or number of unique per tag
  * Yield Tester:
      * added converastion tester - to run during conversation process
      * change name to assembly tester - for running during assembly
      * added inlay data engineering file
      * bug fix for ttfp calculation per matrix
      * added feature for resolve live packet to get the tag external id and calculate yield based on that.
      * update logs and columns names
  * Test Suite Editor:
      * added all optional gw commands
      * added all optional stop criteria and quality parameters


pkgId: 22743b7785504a25c432e6ba2a574c87aaacab9adeb86cde5479c29f1cca391b
name: python-williamtoolbox-help
arch: noarch
version: 0.0.28
epoch: 0
release: 1
summary: Development documents and examples for williamtoolbox
url: https://pypi.org/project/williamtoolbox/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-williamtoolbox-0.0.28-1.src.rpm
location_href: Packages/python-williamtoolbox-help-0.0.28-1.noarch.rpm
checksum_type: sha256
description:
  William Toolbox is an open-source project designed to simplify the management of byzerllm models and auto-cder.RAG (Retrieval-Augmented Generation) systems. It provides a user-friendly interface for deploying, monitoring, and controlling various AI models and RAG setups.

  This project is powered by [auto-coder.chat](https://auto-coder.chat). You can check how we develop this project by reading yamls in directory `auto-coder-actions`.


  ![image](./images/image.png)

  飞书文档链接： https://uelng8wukz.feishu.cn/wiki/R7mswlEn2iROu4kbUezcRyJAnSf?fromScene=spaceOverview



  - 🤖 Model Management: Deploy, start, stop, and monitor AI models
  - 📚 RAG System Management: Create and control RAG setups
  - 🖥️ User-friendly Web Interface: Easy-to-use dashboard for all operations
  - 🔄 Real-time Status Updates: Monitor the status of your models and RAGs
  - 🛠️ Flexible Configuration: Customize model and RAG parameters





  - Python 3.9+



  ```
  pip install -U williamtoolbox
  ```



  0. Create a work directory and cd into it:
     ```
     mkdir william-toolbox && cd william-toolbox
     ```

  1. Start the backend server:
     ```
     william.toolbox.backend
     ```

  2. Start the frontend server:
     ```
     william.toolbox.frontend
     ```

  3. Open your browser and navigate to `http://localhost:8006`



  1. **Adding a Model**: Click on "Add Model" and fill in the required information.
  2. **Managing Models**: Use the model list to start, stop, or check the status of your models.
  3. **Creating a RAG**: Click on "Add RAG" and provide the necessary details.
  4. **Managing RAGs**: Control and monitor your RAG systems from the RAG list.



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  - Thanks to all contributors who have helped shape William Toolbox.
  - Special thanks to the open-source community for providing the tools and libraries that make this project possible.


pkgId: 545737a722599ff2f8d73e099aba3f3a4fbab01ae8de9de8db6907ff4b5245f1
name: python-wincoll-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for wincoll
url: https://github.com/rrthomas/wincoll
rpm_license: GPL v3 or later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wincoll-0.9.2-1.src.rpm
location_href: Packages/python-wincoll-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  https://github.com/rrthomas/wincoll

  by Reuben Thomas <rrt@sc3d.org>

  WinColl is a simple puzzle game in which you tunnel through caverns
  collecting diamonds while avoiding being squashed by falling rocks. It is
  based on [Repton](https://en.wikipedia.org/wiki/Repton_(video_game)) (but
  without eggs and monsters).

  I originally wrote WinColl for Acorn RISC OS. Original and updated [RISC OS
  versions](<https://github.com/rrthomas/wincoll/RISC OS.md>) are available.

  The name of the game is an abbreviation of my school’s. “Repton” is also the
  name of a school, but I don’t believe the game was named after it!




  Level design and graphics also by Alistair Turnbull, Paul Smith and Jeremy
  Douglas. Paul also designed the title graphic.

  The sounds are from [Freesound](https://freesound.org), lightly adapted.




  The game provides instructions on how to play.



  Installers are available for GNU/Linux, macOS and Windows. See the
  [latest release](https://github.com/wincoll/releases):

  * The GNU/Linux version is a single binary; you need to make it executable
    and then either copy it to a directory on your path, or run it directly:
    `chmod +x NAME-OF-FILE; ./NAME-OF-FILE`
  * The macOS version is a disk image file containing an application. Drag the
    application to a suitable location (e.g. your Applications folder). macOS
    will probably refuse to run it until you have approved it in System
    Settings→Privacy and Security, under “Security”.
  * The Windows version is a single `.exe`. Unfortunately it is detected as a
    virus by most virus scanners, including Microsoft Defender, because Python
    apps have often been used to distribute malware. Hence, you will probably
    have to turn off virus scanning before you download it (to prevent it from
    being immediately quarantined or deleted), and then add an exception for
    it. After that, you can put the `.exe` file in a suitable location and
    double-click it to play.



  If you are a Python user, this is the simplest way to get WinColl on most
  machines.

  Install with `pip`: `pip install wincoll`, then execute the command
  `wincoll`.




  Currently, to play edited or new levels you must have a source check-out of
  WinColl from GitHub. (If this doesn’t make sense to you, sorry! I hope to
  provide a simpler way to edit and play new levels soon.)

  The level files are in the `wincoll/levels` subdirectory of the project, and
  are [Tiled](https://www.mapeditor.org/) level editor files, so you will need
  to install Tiled to edit them.

  Having saved an edited level you can install the Python package with
  `pip install .` or run it directly with `PYTHONPATH=. python -m wincoll`.

  Some notes about level design:

  + The supplied levels have a brick wall all the way around. This is
    conventional but not necessary: there’s an imaginary brick wall around the
    outside of the level already.
  + Levels need exactly one start position (represented by placing the Win
    character).
  + No other checks are done to make sure a level is possible to complete; for
    example, you can place diamonds surrounded by bricks, or have safes but no
    key.

  The files are named `Level??.tmx` where the question marks represent two
  decimal digits.

  I welcome [pull requests](https://github.com/rrthomas/wincoll/pulls) for new
  levels.




  WinColl is distributed under the GNU Public License version 3, or, at your
  option, any later version. See the file COPYING.

  THIS PROGRAM IS PROVIDED AS IS, WITH NO WARRANTY. USE IS AT THE USER'S RISK.
  WinColl’s code is copyright Reuben Thomas, and its levels and graphics by
  Reuben Thomas, Alistair Turnbull, Paul Smith and Jeremy Douglas.

  The font “Acorn Mode 1”, which is based on the design of Acorn computers’
  system font, as used on the Acorn Archimedes on which WinColl was originally
  written, is by p1.mark and licensed under CC BY-SA 3.0.

  The sound effects are copyrighted and licensed as follows:

  + Diamond collection:
    [Ding.wav by datasoundsample](https://freesound.org/s/638638/) under CC
    BY 4.0
  + Rock fall:
    [WHITE_NOISE-10s.wav by newagesoup](https://freesound.org/s/349315/)
    under CC 0
  + Safe unlock:
    [Old Church Bell (no noise) by igroglaz](https://freesound.org/s/633208/)
    under CC 0
  + Death splat:
    [Splat1.wav by Shakedown_M](https://freesound.org/s/685205/) under CC 0


pkgId: 5343e95f91339cb6b6ac2e13b06467d71ea108fe62eaed58dbc86c217c0431fd
name: python-windmill-api-help
arch: noarch
version: 1.438.0
epoch: 0
release: 1
summary: Development documents and examples for windmill-api
url: https://pypi.org/project/windmill-api/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-windmill-api-1.438.0-1.src.rpm
location_href: Packages/python-windmill-api-help-1.438.0-1.noarch.rpm
checksum_type: sha256
description:
  This is the raw autogenerated api client. You are most likely more interested in [wmill](https://pypi.org/project/wmill/) which leverages this client to offer an user friendly experience. We use [this openapi python client generator](https://github.com/openapi-generators/openapi-python-client/)


  A client library for accessing Windmill API


  First, create a client:

  ```python
  from windmill_api import Client

  client = Client(base_url="https://api.example.com")
  ```

  If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:

  ```python
  from windmill_api import AuthenticatedClient

  client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
  ```

  Now call your endpoint and use your models:

  ```python
  from windmill_api.models import MyDataModel
  from windmill_api.api.my_tag import get_my_data_model
  from windmill_api.types import Response

  with client as client:
      my_data: MyDataModel = get_my_data_model.sync(client=client)
      
      response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
  ```

  Or do the same thing with an async version:

  ```python
  from windmill_api.models import MyDataModel
  from windmill_api.api.my_tag import get_my_data_model
  from windmill_api.types import Response

  async with client as client:
      my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
      response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
  ```

  By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.

  ```python
  client = AuthenticatedClient(
      base_url="https://internal_api.example.com",
      token="SuperSecretToken",
      verify_ssl="/path/to/certificate_bundle.pem",
  )
  ```

  You can also disable certificate validation altogether, but beware that **this is a security risk**.

  ```python
  client = AuthenticatedClient(
      base_url="https://internal_api.example.com",
      token="SuperSecretToken",
      verify_ssl=False
  )
  ```

  Things to know:
  1. Every path/method combo becomes a Python module with four functions:
      1. `sync`: Blocking request that returns parsed data (if successful) or `None`
      1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
      1. `asyncio`: Like `sync` but async instead of blocking
      1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking

  1. All path/query params, and bodies become method arguments.
  1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
  1. Any endpoint which did not have a tag will be in `windmill_api.api.default`



  There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):

  ```python
  from windmill_api import Client

  def log_request(request):
      print(f"Request event hook: {request.method} {request.url} - Waiting for response")

  def log_response(response):
      request = response.request
      print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")

  client = Client(
      base_url="https://api.example.com",
      httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
  )


  ```

  You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):

  ```python
  import httpx
  from windmill_api import Client

  client = Client(
      base_url="https://api.example.com",
  )

  client.set_httpx_client(httpx.Client(base_url="https://api.example.com", proxies="http://localhost:8030"))
  ```


pkgId: a8f1152100740753e0faec546ff842db3bb9299c701e02427a44364422cae229
name: python-wings-easy-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for wings-easy
url: https://github.com/5hmlA/PyTools
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wings-easy-0.1-1.src.rpm
location_href: Packages/python-wings-easy-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  > 使用Python打开自己的工程，然后点击Tools，最后点击Sync Python Requirements
  >
  > **pip install -r requirements.txt**



   - 确保 requirements.txt 文件位于项目的根目录。
   - 在提交代码到版本控制系统之前，更新 requirements.txt 文件。
   - 在使用 pip install -r requirements.txt 安装依赖项时，确保使用与项目环境匹配的 Python 版本。





  >--hidden-import 设置导入要动态加载的类 因为没被引用 所以不会导入需要手动设置
  >
  >上述命令中的选项说明：
  >
  >-n NAME, --name NAME: 可执行文件名称。
  >
  >-F, --onefile: 将整个项目打包为一个单独的可执行文件。
  >
  >-w, --windowed, --noconsole: 隐藏控制台窗口，将打包的应用程序显示为GUI应用程序。
  >
  >--add-data: 添加项目资源，支持文件夹和文件，前面是资源路径，后面是输出路径，用分号进行分割。
  >
  >-i <FILE.ico>, --icon <FILE.ico> :  指定icon
  >
  >执行上述命令后，会在项目目录下生成一个.spec文件，这个文件会告诉PyInstaller如何将项目打包成exe文件。



  - ### <span style="color: red;">无法将“pyinstaller”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括路径，请确保路径正确，然后再试一次。</span>

    > 解决方案: 安装 PyInstaller
    >
    > pip install PyInstaller
    >
    > pyinstaller --name=<your_exe_name> --onefile --windowed --add-data "<your_data_folder>;<your_data_folder>" <your_script_name>.py


  - ### <span style="color: red;">win32ctypes.pywin32.pywintypes.error: (225, 'EndUpdateResourceW', '无法成功完成操作，因为文件包含病毒或潜在的垃圾软件。</span>

    > 不使用-w --noconsole的命令打包隐藏命令行窗口时，是正常的，
    >
    > 但是使用-w或者--noconsole就会报错win32ctypes.pywin32.pywintypes.error: (225, '', '无法成功完成操作，因为文件包含病毒或潜在的垃圾软件。')
    >
    > 解决方案: 降级 PyInstaller, 安装6.2.0重新打包即可
    >
    > pip install pyinstaller==6.2.0


pkgId: 820411c74bd8cef29fb0a6b86992168032bf76222904fda8e5026c90c459bb59
name: python-winwin-help
arch: noarch
version: 0.0.47
epoch: 0
release: 1
summary: Development documents and examples for winwin
url: https://pypi.org/project/winwin/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-winwin-0.0.47-1.src.rpm
location_href: Packages/python-winwin-help-0.0.47-1.noarch.rpm
checksum_type: sha256
description:
  ```
  pip install winwin

  pip install git+http://{USER}:{PASSWORD}@codeup.aliyun.com:msy/ml/winwin.git

  pip install winwin -i http://sys-3007.zhidou.hz:19900/simple/ --trusted-host sys-3007.zhidou.hz
  ```



  ```
  import winnwin
  winwin.__version__
  ```


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

  Get daily Horoscope using https://horoscope-app-api.vercel.app by [Ashutosh Krishna](https://horoscope-app-api.vercel.app)


  Exploring astro API for personal project inspired by friend's interest in astrology.




  First [install winzy](https://github.com/sukhbinder/winzy) by typing

  ```bash
  pip install winzy
  ```

  Then install this plugin in the same environment as your Winzy application.
  ```bash
  winzy install winzy-horoscope
  ```


  Demo of usage

  ![winzy-horoscope-demo.gif](https://raw.githubusercontent.com/sukhbinder/windy-horoscope/main/winzy-horoscope-demo.gif)



  To set up this plugin locally, first checkout the code. Then create a new virtual environment:
  ```bash
  cd winzy-horoscope
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```


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

  Create reminders in macos with cli



  First [install winzy](https://github.com/sukhbinder/winzy) by typing

  ```bash
  pip install winzy
  ```

  Then install this plugin in the same environment as your Winzy application.
  ```bash
  winzy install winzy-macos-reminder
  ```


  ```bash
  usage: winzy remind [-h] [-dt DATETIME] [-df DATE_FORMAT] description

  Create reminders in macos with cli

  positional arguments:
    description           The description of the reminder.

  optional arguments:
    -h, --help            show this help message and exit
    -dt DATETIME, --datetime DATETIME
                          The date and time for the reminder (e.g., '16 December 10am').
    -df DATE_FORMAT, --date-format DATE_FORMAT
                          The expected date format (default: '%d/%m/%Y').

  ```



  To set up this plugin locally, first checkout the code. Then create a new virtual environment:
  ```bash
  cd winzy-macos-reminder
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```


pkgId: 5d9ff98848ffd8bd265dd527bc05e8f4ff9f112c68b53a18b4837fc29e4f0d2a
name: python-wlkatapython-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for wlkatapython
url: https://pypi.org/project/wlkatapython/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wlkatapython-0.1.0-1.src.rpm
location_href: Packages/python-wlkatapython-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **&nbsp;&nbsp;&nbsp;&nbsp;This is a package that uses Python to control products such as Mirobot robotic arms, E4 robotic arms, slides, conveyor belts, etc. This package mainly communicates through pyserial and G code protocols. Currently, it supports RS485 or UART communication. It should be noted that when using this package, a multi-functional controller is required, as some functions of the modified package use multi-functional controllers. If the mechanical arm is directly connected, some functions may not be effective.**




  **&nbsp;&nbsp;&nbsp;&nbsp;Wlkatapython is a Python package used to control products such as Mirobot robotic arms, E4 robotic arms, slides, conveyor belts, etc.**

  **&nbsp;&nbsp;&nbsp;&nbsp;This component uses the G code protocol to communicate with the Mirobot over a serial connection. The official**

  **&nbsp;&nbsp;&nbsp;&nbsp;G code instruction set** and **driver download** can be found at the [WLkata Download Page](https://www.wlkata.com/pages/download-center)



  <div style="text-align: center;">
    <img src="./img/img1.png" style="width: 50%;">
  </div>



  ```python
  import wlkatapython
  import serial
  import time

  "Robot arm returns to zero"
  Serial1=serial.Serial ("COM3", 38400) # Set serial port and baud rate
  Mirobot1=wlkatapython.Mirobot_UART() # Create a new mirobot1 object
  Mirobot1.init (serial1, 1) # Set the address of the robotic arm
  Mirobot1.homing() # Robot arm zeroing
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial

  "Execute offline files"
  Serial1=serial.Serial ("COM3", 38400) # Set serial port and baud rate
  Mirobot1=wlkatapython.Mirobot_UART() # Create a new mirobot1 object
  Mirobot1.init (serial1, 1) # Set the address of the robotic arm
  Mirobot1.runFile ("ceshi", False) # Execute a file in a loop. True is the loop execution file, and False is the single execution file
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial
  import time

  "Stop the current program"
  Serial1=serial.Serial ("COM3", 38400) # Set serial port and baud rate
  Mirobot1=wlkatapython.Mirobot_UART() # Create a new mirobot1 object
  Mirobot1.init (serial1, 1) # Set the address of the robotic arm
  Mirobot1.runFile ("ceshi", True) # Loop execution of a file, True is the loop execution file, False is the single execution file
  time.sleep (5) # Wait for 5 seconds
  Mirobot1.cancelation() # Stop the currently running program
  Serial1.close() # Close serial port
  ```



  <div style="text-align: center;">
    <img src="./img/img2.png" style="width: 30%;">
    <img src="./img/img3.png" style="width: 50%;">
  </div>



  ```python
  import wlkatapython
  import serial
  import time

  "Robot arm returns to zero"
  Serial1=serial.Serial ("COM3", 115200) # Set serial port and baud rate
  Mirobot1=wlkatapython.Mirobot_UART() # Create a new mirobot1 object
  Mirobot1.init (serial1, -1) # Set the address of the robotic arm
  Mirobot1.homing() # Robot arm zeroing
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial

  "Execute offline files"
  Serial1=serial.Serial ("COM3", 115200) # Set serial port and baud rate
  Mirobot1=wlkatapython.Mirobot_UART() # Create a new mirobot1 object
  Mirobot1.init (serial1, -1) # Set the address of the robotic arm
  Mirobot1.runFile ("ceshi", False) # Execute a file in a loop. True is the loop execution file, and False is the single execution file
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial
  import time

  "Stop the current program"
  Serial1=serial.Serial ("COM3", 115200) # Set serial port and baud rate
  Mirobot1=wlkatapython.Mirobot_UART() # Create a new mirobot1 object
  Mirobot1.init (serial1, -1) # Set the address of the robotic arm
  Mirobot1.runFile ("ceshi", True) # Loop execution of a file, True is the loop execution file, False is the single execution file
  time.sleep (5) # Wait for 5 seconds
  Mirobot1.cancelation() # Stop the currently running program
  Serial1.close() # Close serial port
  ```



  <div style="text-align: center;">
    <img src="./img/img4.png" style="width: 50%;">
  </div>


  **&nbsp;&nbsp;&nbsp;&nbsp;Mainly used for debugging the Cartesian positioning of robotic arms on devices that are inconvenient to install and use with Wlkatastudio.**



  ```python
  import wlkatapython
  """
  Mirobot_Serial_GUI
  """
  Mirobot_GUI=wlkatapython.Mirobot_Serial_GUI()
  Mirobot_GUI.Mirobot_GUI()
  ```



  <div style="text-align: center;">
    <img src="./img/MT4_RS485.png" style="width: 50%;">
  </div>



  ```python
  import wlkatapython
  import serial

  "Robot arm returns to zero"
  Serial1=serial.Serial ("COM3", 38400) # Set serial port and baud rate
  MT4_1=wlkatapython.MT4_UART() # Create a new MT4_1 object
  MT4_1.init (serial1, 1) # Set the address of the robotic arm
  MT4_1.homeing() # Robot arm zeroing
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial

  "Execute offline files"
  Serial1=serial.Serial ("COM3", 38400) # Set serial port and baud rate
  MT4_1=wlkatapython.MT4_UART() # Create a new MT4_1 object
  MT4_1.init (serial1, 1) # Set the address of the robotic arm
  MT4_1.runFile ("ceshi", False) # Execute a file in a loop. True is the loop execution file, and False is the single execution file
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial
  import time

  "Stop the current program"
  Serial1=serial.Serial ("COM3", 38400) # Set serial port and baud rate
  MT4_1=wlkatapython.MT4_UART() # Create a new MT4_1 object
  MT4_1.init (serial1, 1) # Set the address of the robotic arm
  MT4_1.runFile ("ceshi", True) # Loop execution of a file, True is the loop execution file, False is the single execution file
  time.sleep (5) # Wait for 5 seconds
  MT4_1.cancelation() # Stop the currently running program
  Serial1.close() # Close serial port
  ```



  <div style="text-align: center;">
    <img src="./img/MT4_UART.png" style="width: 50%;">
  </div>



  ```python
  import wlkatapython
  import serial

  "Robot arm returns to zero"
  Serial1=serial.Serial ("COM3", 115200) # Set serial port and baud rate
  MT4_1=wlkatapython.MT4_UART() # Create a new MT4_1 object
  MT4_1.init (serial1, -1) # Set the address of the robotic arm
  MT4_1.homing() # Robot arm zeroing
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial

  "Execute offline files"
  Serial1=serial.Serial ("COM3", 115200) # Set serial port and baud rate
  MT4_1=wlkatapython.MT4_UART() # Create a new MT4_1 object
  MT4_1.init (serial1, -1) # Set the address of the robotic arm
  MT4_1.runFile ("ceshi", False) # Execute a file in a loop. True is the loop execution file, and False is the single execution file
  Serial1.close() # Close serial port
  ```

  ```python
  import wlkatapython
  import serial
  import time

  "Stop the current program"
  Serial1=serial.Serial ("COM3", 115200) # Set serial port and baud rate
  MT4_1=wlkatapython.MT4_UART() # Create a new MT4_1 object
  MT4_1.init (serial1, -1) # Set the address of the robotic arm
  MT4_1.runFile ("ceshi", True) # Loop execution of a file, True is the loop execution file, False is the single execution file
  time.sleep (5) # Wait for 5 seconds
  MT4_1.cancelation() # Stop the currently running program
  Serial1.close() # Close serial port
  ```



  <div style="text-align: center;">
    <img src="./img/MS4220.png" style="width: 50%;">
  </div>



  ```python
  import wlkatapython
  import serial
  import time

  Serial1=serial.Serial ("COM3", 38400)
  MS4220_1=wlkatapython.MS4220_UART()
  MS4220_1.init(Serial1,10)
  MS4220_1.speed(100)
  time.sleep(5)
  MS4220_1.speed(-100)
  time.sleep(5)
  MS4220_1.speed(0)
  ```



  **&nbsp;&nbsp;&nbsp;&nbsp;Please contact wlkata personnel for further instructions.[WLkata Download Page](https://www.wlkata.com/pages/download-center)**


pkgId: f3fac112da52fb59c88e066762fd42be6e13e0c87d9f2e58b82e207d83ab791d
name: python-wmill-pg-help
arch: noarch
version: 1.438.0
epoch: 0
release: 1
summary: Development documents and examples for wmill-pg
url: https://windmill.dev
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wmill-pg-1.438.0-1.src.rpm
location_href: Packages/python-wmill-pg-help-1.438.0-1.noarch.rpm
checksum_type: sha256
description:
  The postgres extension client for the [Windmill](https://windmill.dev) platform.

  [windmill-api](https://pypi.org/project/windmill-api/).



  ```python
  import wmill_pg


  def main():
      my_list = query("UPDATE demo SET value = 'value' RETURNING key, value")
      for key, value in my_list:
          ...
  ```


pkgId: 65a447ef305273ec62540409cb37fcea2b05f10fdc63c3f98a05cff285a9b3c2
name: python-wmsan-help
arch: noarch
version: 2024.1.3
epoch: 0
release: 1
summary: Development documents and examples for wmsan
url: https://gricad-gitlab.univ-grenoble-alpes.fr/tomasetl/ww3-source-maps/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wmsan-2024.1.3-1.src.rpm
location_href: Packages/python-wmsan-help-2024.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/793568997.svg)](https://zenodo.org/doi/10.5281/zenodo.13374110)


  This package is built to help computation of seismic ambient noise source maps and other products based on the WAVEWATCHIII hindcast output.


  A detailed documentation is available [on this page](https://tomasetl.gricad-pages.univ-grenoble-alpes.fr/ww3-source-maps/).


  ```
  ww3-source-maps/
  |-- LICENSE
  |-- pyproject.toml
  |-- README.md
  |-- mkdocs.yml
  |-- docs/
  |-- site/
  |-- src/
  │   └── wmsan/
  │       ├── readWW31.py
  │       ├── read_hs_p2l.py
  │       ├── subfunctions_body_waves.py
  │       ├── subfunctions_rayleigh_waves.py
  │       └── synthetics.py
  │       └── wmsan_to_noisi.py
  │       └── temporal_variation.py
  │       └── synthetic_CCF.ipynb
  │
  |-- notebooks/
  |   └── body_waves/
  │       ├── amplification_coeff.ipynb
  │       └── microseismic_sources.ipynb
  │   └── rayleigh_waves/
  │       ├── amplification_coeff.ipynb
  │       ├── microseismic_sources.ipynb
  │       ├── spectrograms.ipynb
  │       ├── rayleigh_source.ipynb
  │       └── synthetic_CCF.ipynb
  │       └── wmsan_to_noisi.ipynb
  │       └── temporal_variations.ipynb
  |-- data/
  │   ├── C.nc
  │   ├── cP.nc
  │   ├── cS.nc
  │   ├── longuet_higgins.txt
  │   ├── stations_pair.txt
  │   └── ww3.07121700.dpt
  ```
  - src/ : contains all Python scripts and subfunctions.
  - notebooks/ : contains Jupyter Notebooks with detailed examples on how to use this package. Rayleigh waves and body waves are separated.
  - data/: contains additional files used in computation.





  The package is available on [PyPI](https://pypi.org/).

  - Create an environment and install

      - if you use [Conda](https://docs.anaconda.com/free/miniconda/#quick-command-line-install) environments:

              conda create --name wmsan
              conda activate wmsan
              conda install pip
              python3 -m pip install wmsan

          to deactivate your environment:

              conda deactivate

      - otherwise

              python3 -m venv venv
              source venv/bin/activate
              python3 -m pip install wmsan

          to deactivate your environment:

              deactivate


  1. Clone the repository
  ```
  cd path_to_your_wmsan_directory/
  git clone https://gricad-gitlab.univ-grenoble-alpes.fr/tomasetl/ww3-source-maps.git
  cd ww3-source-maps/
  ````
  2. Create an environment and install
  - if you use [Conda](https://docs.anaconda.com/free/miniconda/#quick-command-line-install) environments:
  ```
  conda create --name wmsan
  conda activate wmsan
  conda install pip
  pip install .
  ```
  to deactivate your environment:
  ```
  conda deactivate
  ```

  - otherwise
  ```
  python3 -m venv venv
  source venv/bin/activate
  python3 -m pip install .
  ```
  to deactivate your environment:
  ```
  deactivate
  ```



  - [numpy](https://numpy.org/doc/stable/)
  - [matplotlib](https://matplotlib.org/stable/)
  - [cartopy](https://scitools.org.uk/cartopy/docs/latest/index.html)
  - [xarray](https://docs.xarray.dev/en/stable/)
  - [netCDF4](https://unidata.github.io/netcdf4-python/)
  - [obspy](https://docs.obspy.org/)
  - [datetime](https://docs.python.org/3/library/datetime.html)
  - [scipy](https://scipy.org/)
  - [pandas](https://pandas.pydata.org/pandas-docs/version/2.1.4/index.html)
  - [dask](https://www.dask.org/)
  - [ipykernel](https://pypi.org/project/ipykernel/)
  - [pyproj](https://pyproj4.github.io/pyproj/stable/)
  - [h5py](https://docs.h5py.org/en/stable/)
  - [tqdm](https://tqdm.github.io/)
  - [notebook](https://jupyter-notebook.readthedocs.io/en/stable/)



  ![Table representing the differrent paths to Jupyter Notebooks examples and where to find what you wish to compute.](https://gricad-gitlab.univ-grenoble-alpes.fr/tomasetl/ww3-source-maps/-/raw/main/sumup.png)



  ![Scheme showing the different codes and Notebooks present in this repository and how they connect.](https://gricad-gitlab.univ-grenoble-alpes.fr/tomasetl/ww3-source-maps/-/raw/main/package_archi.png)


pkgId: ed72747dc6871fc984e4e19b4ce3afb5b22616f97249db9940aa4385972b0d43
name: python-wonday-scanner-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for wonday-scanner
url: https://github.com/yourusername/wonday-scanner
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wonday-scanner-1.0.0-1.src.rpm
location_href: Packages/python-wonday-scanner-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A comprehensive web security scanner that performs various security checks including OWASP Top 10 vulnerabilities.


  - Information Gathering
    - DNS Information
    - WHOIS Information
    - Port Scanning
    - Technology Stack Detection
    - Server Information Analysis

  - Directory Scanning
    - Multi-threaded Scanning
    - Custom Wordlist Support
    - Response Size Analysis

  - Vulnerability Assessment
    - OWASP Top 10 Checks
    - Security Headers Analysis
    - SSL/TLS Configuration
    - Injection Vulnerabilities
    - Access Control Testing
    - Information Disclosure


pkgId: 360903e9e6ce96656c7acb77cfd73924c98f1fc2aedbd1c758a79a7ada4151cd
name: python-workflowai-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for workflowai
url: https://pypi.org/project/workflowai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-workflowai-0.5.3-1.src.rpm
location_href: Packages/python-workflowai-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  A library to use WorkflowAI with Python



  `workflowai` requires a python >= 3.9.

  ```sh
  pip install workflowai
  ```



  Usage examples are available in the [examples](./examples/) directory.



  ```python
  import workflowai

  wai = workflowai.start(
      url=..., # defaults to WORKFLOWAI_API_URL env var or https://api.workflowai.com
      api_key=..., # defaults to WORKFLOWAI_API_KEY env var
  )
  ```



  We use pydantic for type definitions.

  ```python
  from pydantic import BaseModel, Field

  from workflowai import Task, TaskVersionReference

  class CityToCapitalTaskInput(BaseModel):
      city: str


  class CityToCapitalTaskOutput(BaseModel):
      capital: str

  class CityToCapitalTask(Task[CityToCapitalTaskInput, CityToCapitalTaskOutput]):
      id: str = "citytocapital"
      schema_id: int = 1
      input_class: type[CityToCapitalTaskInput] = CityToCapitalTaskInput
      output_class: type[CityToCapitalTaskOutput] = CityToCapitalTaskOutput

      
      version: TaskVersionReference = TaskVersionReference(
          iteration=4,
      )
  ```



  ```python
  task = CityToCapitalTask()
  task_input = CityToCapitalTaskInput(city=city)
  task_run = await wai.run(task, task_input)

  print(task_run.task_output)
  ```

  It is also possible to stream a task output

  ```python
  task = CityToCapitalTask()
  task_input = CityToCapitalTaskInput(city=city)
  iterator = await wai.run(task, task_input, stream=True)
  async for chunk in iterator:
      print(chunk) # chunk is a partial (non validated) CityToCapitalTaskOutput
  ```


pkgId: b89d932b82e279b5e7962f89ecc5cd7257f9d0c930ec6c526b128a22157673dd
name: python-working-ujson-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for working-ujson
url: https://pypi.org/project/working-ujson/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-working-ujson-0.0.1-1.src.rpm
location_href: Packages/python-working-ujson-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ujson bilan ishlaydigan kutubxona

  ```

  data = {
      'name': 'valijon'
  }

  filename = 'data.json'

  write_json(filename, data)

  ```


pkgId: bc261619d7dd30f666c04dd5e1c13ce47e4901e35fa8d09751be3b7a85cf55e9
name: python-wox-plugin-help
arch: noarch
version: 0.0.29
epoch: 0
release: 1
summary: Development documents and examples for wox-plugin
url: https://pypi.org/project/wox-plugin/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wox-plugin-0.0.29-1.src.rpm
location_href: Packages/python-wox-plugin-help-0.0.29-1.noarch.rpm
checksum_type: sha256
description:
  This package provides type definitions for developing Wox plugins in Python.



  - Python >= 3.8 (defined in `pyproject.toml`)
  - Python 3.12 recommended for development (defined in `.python-version`)



  ```bash

  pip install wox-plugin


  uv add wox-plugin
  ```



  ```python
  from wox_plugin import BasePlugin, Query, Result, Context, PluginInitParams

  class MyPlugin(BasePlugin):
      async def init(self, ctx: Context, params: PluginInitParams) -> None:
          self.api = params.API

      async def query(self, ctx: Context, query: Query) -> list[Result]:
          
          results = []
          results.append(
              Result(
                  title="Hello Wox",
                  subtitle="This is a sample result",
                  icon="path/to/icon.png",
                  score=100
              )
          )
          return results


  plugin = MyPlugin()
  ```



  MIT


pkgId: dcf847f884e3c956267dd479ed1ad41d84e2b04eb440acde583e89248b3d994a
name: python-wp-engine-api-python-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for wp-engine-api-python
url: https://github.com/jpollock/wp-engine-api-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wp-engine-api-python-0.0.2-1.src.rpm
location_href: Packages/python-wp-engine-api-python-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python SDK for interacting with the WP Engine API, enabling Python developers to programmatically interact with WP Engine services.

  > **Note**: This SDK is maintained by Jeremy Pollock (jeremy.pollock@wpengine.com) and is not affiliated with or supported by WP Engine.



  ```bash
  pip install wp-engine-api
  ```



  The SDK supports two methods of authentication:



  ```python
  from wp_engine_api import WPEngineAPI


  client = WPEngineAPI(
      username="your-username",
      password="your-password"
  )
  ```



  Create a `.env` file in your project root:
  ```bash
  WP_ENGINE_API_USERNAME=your-username
  WP_ENGINE_API_PASSWORD=your-password
  ```

  Or set environment variables directly:
  ```bash
  export WP_ENGINE_API_USERNAME=your-username
  export WP_ENGINE_API_PASSWORD=your-password
  ```

  Then initialize the client:
  ```python
  from wp_engine_api import WPEngineAPI


  client = WPEngineAPI()
  ```



  ```python
  from wp_engine_api import WPEngineAPI


  client = WPEngineAPI(
      username="your-username",
      password="your-password"
  )


  sites = client.sites.list()
  for site in sites:
      print(f"Site: {site.name} ({site.id})")


  site = client.sites.get("site_id")


  backup = client.backups.create(
      "site_id",
      {
          "description": "Pre-deployment backup",
          "notification_emails": ["admin@example.com"]
      }
  )
  ```



  - Full coverage of the WP Engine API
  - Type hints for better IDE support
  - Automatic rate limiting
  - Request validation
  - Comprehensive error handling
  - Environment variable support
  - .env file support





  ```python

  sites = client.sites.list()


  site = client.sites.get("site_id")


  updated_site = client.sites.update(
      "site_id",
      {"name": "New Site Name"}
  )
  ```



  ```python

  backup = client.backups.create(
      "site_id",
      {
          "description": "Pre-deployment backup",
          "notification_emails": ["admin@example.com"]
      }
  )


  backups = client.backups.list("site_id")


  backup_status = client.backups.get("site_id", "backup_id")
  ```



  ```python
  from wp_engine_api.exceptions import (
      AuthenticationError,
      ValidationError,
      ResourceNotFoundError,
      RateLimitError
  )

  try:
      sites = client.sites.list()
  except AuthenticationError:
      print("Invalid credentials")
  except ResourceNotFoundError:
      print("Resource not found")
  except RateLimitError as e:
      print(f"Rate limit exceeded. Retry after {e.retry_after} seconds")
  except ValidationError as e:
      print(f"Invalid request: {e}")
  ```



  The SDK includes automatic rate limiting to help you stay within the API's limits. You can configure the rate limiting behavior:

  ```python
  client = WPEngineAPI(
      username="your-username",
      password="your-password",
      max_retries=3,
      retry_delay=1.0
  )
  ```





  1. Clone the repository:
  ```bash
  git clone https://github.com/wpengine/wp-engine-api-python.git
  cd wp-engine-api-python
  ```

  2. Create a virtual environment:
  ```bash
  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  ```

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



  ```bash
  pytest
  ```



  The SDK uses OpenAPI Generator to generate the base API client code. To regenerate the client:

  ```bash
  python scripts/generate_client.py
  ```



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



  This SDK is maintained by Jeremy Pollock (jeremy.pollock@wpengine.com). For any questions, issues, or contributions, please reach out directly.


pkgId: d311709de6c3e3aacc151c647d4ad0dcf3d1d998cb735d28fff32a38e0416fb5
name: python-wrap-technote-help
arch: noarch
version: 0.107
epoch: 0
release: 1
summary: Development documents and examples for wrap-technote
url: https://github.com/dew-waterscience/wrap_technote
rpm_license: All rights reserved @ DEW
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wrap-technote-0.107-1.src.rpm
location_href: Packages/python-wrap-technote-help-0.107-1.noarch.rpm
checksum_type: sha256
description:
  Code to process groundwater and rainfall data for the annual Water Resource Assessment Program technical notes.



  The source code is on [Bitbucket](https://bitbucket.org/dewsurfacewater/wrap_technote), while Python packages (source and binary) are published on
  the [Python Package Index](https://pypi.org/project/wrap-technote/) and
  on a dedicated channel on [Anaconda Cloud](https://anaconda.org/dew-waterscience/repo).



  Run this in Command Prompt to install from PyPI:

  ```
  pip install wrap_technote
  ```

  To upgrade to the latest version:

  ```
  pip install -U wrap_technote
  ```



  You can also install using conda/mamba if you prefer:

  ```
  mamba install -c dew-waterscience wrap_technote
  ```

  To upgrade:

  ```
  mamba upgrade -c dew-waterscience wrap_technote
  ```

  The version may not be as up-to-date as the PyPI version.



  This is how you can install the latest version of the source code directly from Bitbucket (the version control repository):

  ```
  python -m pip install git+https://kinveraritysagov@bitbucket.org/dewsurfacewater/wrap_technote.git
  ```

  You will need to replace ``kinveraritysagov`` with your Bitbucket username, and you will also need access to the source repository on the Bitbucket dewsurfacewater workspace.



  Check out complete documentation at:

  [http://bunyip:8191/python-docs/wrap_technote/latest_source/index.html](http://bunyip:8191/python-docs/wrap_technote/latest_source/index.html)



  All rights reserved DEW 2023


pkgId: 2f70d423149b4e8aa3a994bab6dbc2089e3153b19c117724f788711852b4b2c7
name: python-wrapper-tls-requests-help
arch: noarch
version: 1.0.7
epoch: 0
release: 1
summary: Development documents and examples for wrapper-tls-requests
url: https://github.com/thewebscraping/tls-requests
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wrapper-tls-requests-1.0.7-1.src.rpm
location_href: Packages/python-wrapper-tls-requests-help-1.0.7-1.noarch.rpm
checksum_type: sha256
description:
  To install the library, you can choose between two methods:

  ```shell
  pip install wrapper-tls-requests
  ```

  ```shell
  pip install git+https://github.com/thewebscraping/tls-requests.git
  ```


pkgId: 91b864b6f65cbff893b2b7e4a8e21d34932aadaa351693e998ef4ee688b37c07
name: python-wreck-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for wreck
url: https://pypi.org/project/wreck/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wreck-0.2.2-1.src.rpm
location_href: Packages/python-wreck-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  From .in requirement files generate and fix .lock and .unlock files
  |  |kit| |codecov| |license|
  |  |last-commit| |test-status| |quality-status| |docs|
  |  |versions| |implementations|
  |  |platforms| |black|
  |  |downloads| |stars|
  |  |mastodon-msftcangoblowm|
  |feature banner|
  \* Python 3.9 through 3.13, PyPy
  **new in 0.2.x**
  compatible release operator support; arbitrary equality issue UnResolvable;
  **new in 0.1.x**
  fork portion of drain-swamp;

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


pkgId: 2f1e20d2debdc8737b996142a08d9235e6fcf73bccf77c1d6a6f5b936444f318
name: python-writer-help
arch: noarch
version: 0.8.2
epoch: 0
release: 1
summary: Development documents and examples for writer
url: https://www.writer.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-writer-0.8.2-1.src.rpm
location_href: Packages/python-writer-help-0.8.2-1.noarch.rpm
checksum_type: sha256
description:
  Writer Framework is an open-source framework for creating AI applications. Build user interfaces using a visual editor; write the backend code in Python.

  Writer Framework is fast and flexible with a clean, easily-testable syntax. It provides separation of concerns between UI and business logic, enabling more complex applications.





  Writer Framework is **fully state-driven** and provides **separation of concerns** between user interface and business logic.

  ```py
  import writer as wf

  def handle_increment(state):
      state["counter"] += 1

  wf.init_state({
      "counter": 0
  })
  ```

  The user interface is a template, which is defined visually. The template contains reactive references to state, e.g. `@{counter}`, and references to event handlers, e.g. when _Button_ is clicked, trigger `handle_increment`.



  - Elements are highly customizable with no CSS required, allowing for shadows, button icons, background colors, etc.
  - HTML elements with custom CSS can be included using the _HTML Element_ component. They can serve as containers for built-in components.



  - Event handling adds minimal overhead to your Python code (~1-2ms\*).
  - Streaming (WebSockets) is used to synchronize frontend and backend states.
  - The script only runs once.
  - Non-blocking by default. Events are handled asynchronously in a thread pool running in a dedicated process.

  \*End-to-end figure, including DOM mutation. Tested locally on a Macbook Air M2. [Measurement methodology](https://medium.com/@ramiromedina/measuring-time-elapsed-between-an-event-and-its-associated-dom-mutation-80431ad576e1).



  - It's all contained in a standard Python package, just one `pip install` away.
  - User interfaces are saved as JSON, so they can be version controlled together with the rest of the application.
  - Use your local code editor and get instant refreshes when you save your code. Alternatively, use the provided web-based editor.
  - You edit the UI while your app is running. No hitting "Preview" and seeing something completely different to what you expected.



  Getting started with Writer Framework is easy. It works on Linux, Mac and Windows.

  ```sh
  pip install writer
  writer hello
  ```

  - The first command will install Writer Framework using `pip`.
  - The second command will create a demo application in the subfolder "hello" and start Writer Framework Builder, the framework's visual editor, which will be accessible via a local URL.

  The following commands can be used to create, launch Writer Framework Builder and run an application.

  ```sh
  writer create my_app
  writer edit my_app
  writer run my_app
  ```



  Full documentation, including how to use Writer's AI module and deployment options, is available at [Writer](https://dev.writer.com/framework?utm_source=github&utm_medium=readme&utm_campaign=framework).



  Writer is the full-stack generative AI platform for enterprises. Quickly and easily build and deploy generative AI apps with a suite of developer tools fully integrated with our platform of LLMs, graph-based RAG tools, AI guardrails, and more. Learn more at [writer.com](https://www.writer.com?utm_source=github&utm_medium=readme&utm_campaign=framework).



  This project is licensed under the Apache 2.0 License.


pkgId: 3e42091487bb088f11c789c57b2ae07bbb06059678712b0f9d7de5eadfd74d78
name: python-wrk-platform-sdk-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for wrk-platform-sdk
url: https://pypi.org/project/wrk-platform-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wrk-platform-sdk-1.1.0-1.src.rpm
location_href: Packages/python-wrk-platform-sdk-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  *LaunchesApi* | [**get_launch_by_id**](docs/LaunchesApi.md#get_launch_by_id) | **GET** /launch/{launch_id} | Fetch a specific Wrkflow Launch
  *LaunchesApi* | [**get_launches**](docs/LaunchesApi.md#get_launches) | **GET** /launch | Fetch multiple Wrkflow Launches
  *LaunchesApi* | [**launch_wrkflow**](docs/LaunchesApi.md#launch_wrkflow) | **POST** /wrkflow/{wrkflow_uuid}/launch | Launch a Wrkflow
  *LaunchesApi* | [**pause_launch**](docs/LaunchesApi.md#pause_launch) | **POST** /launch/{launch_id}/pause | Pause a Wrkflow Launch
  *LaunchesApi* | [**resume_launch**](docs/LaunchesApi.md#resume_launch) | **POST** /launch/{launch_id}/resume | Resume a Wrkflow Launch
  *WrkflowsApi* | [**get_wrkflow_by_uuid**](docs/WrkflowsApi.md#get_wrkflow_by_uuid) | **GET** /wrkflow/{wrkflow_uuid} | Fetch a specific Wrkflow
  *WrkflowsApi* | [**get_wrkflows**](docs/WrkflowsApi.md#get_wrkflows) | **GET** /wrkflow | Fetch multiple Wrkflows

   - [GetLaunchByIdResponse](docs/GetLaunchByIdResponse.md)
   - [GetLaunchesResponse](docs/GetLaunchesResponse.md)
   - [GetWrkflowByUuidResponse](docs/GetWrkflowByUuidResponse.md)
   - [GetWrkflowsResponse](docs/GetWrkflowsResponse.md)
   - [Launch](docs/Launch.md)
   - [LaunchState](docs/LaunchState.md)
   - [LaunchWrkflowRequest](docs/LaunchWrkflowRequest.md)
   - [LaunchWrkflowResponse](docs/LaunchWrkflowResponse.md)
   - [WrkError](docs/WrkError.md)
   - [WrkErrorDetails](docs/WrkErrorDetails.md)
   - [Wrkflow](docs/Wrkflow.md)
   - [WrkflowSchedule](docs/WrkflowSchedule.md)
  <a id="documentation-for-authorization"></a>

  Authentication schemes defined for the API:
  <a id="ApiKeyAuth"></a>

  - **Type**: API key
  - **API key parameter name**: Authorization
  - **API key prefix**: Api-Key
  - **Location**: HTTP header


pkgId: 6e43d918c16713504adcaf4b903cff882e2f47f0fa8bfc66d23e0820a5008d0f
name: python-wsenedis-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for wsenedis
url: https://github.com/jplartigue/webservices-enedis
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wsenedis-0.5.0-1.src.rpm
location_href: Packages/python-wsenedis-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  Actuellement, neuf services sont disponibles, chacun étant défini dans le projet via une classe dédiée contenant les méthodes nécessaires pour communiquer avec les webservices d'Enedis. Les objets à passer en paramètre des méthodes sont décrits dans le chapitre consacré au sous-module `webservices_enedis_common`.
  1. **`ConsulterDonneesTechniquesContractuelles`**
     Permet de consulter les données techniques d'un point. Utilisez la méthode `consultation_donnees_techniques_contractuelles(point)` en passant un objet de type `Point` en argument.
  2. **`ConsulterMesures`**
     Permet de consulter l'historique des consommations d'un point. Utilisez la méthode `consulter_mesures(donnees_consulter_mesures)` en passant un objet de type `DonneesConsulterMesures` en argument.
  3. **`ConsulterMesuresDetaillees`**
     Permet de consulter les données détaillées d'un point. Utilisez la méthode `consulter_mesures_detaillees(demande)` en passant un objet de type `DemandeConsulterMesuresDetaillees` en argument.
  4. **`RecherchePoint`**
     Permet de rechercher un point dans le système d'Enedis. Utilisez la méthode `recherche_point(criteres)` en passant un objet de type `Criteres` en argument.
  5. **`CommanderCollectePublicationMesures`**
     Permet de collecter des données ou de demander une transmission récurrente de données sur le point concerné. Utilisez la méthode `commander_collecte_publication(demande_collecte)` en passant un objet de type `DemandeCollecte` en argument.
  6. **`RechercheServicesSouscritsMesures`**
     Permet de récupérer les données des services souscrits sur un point. Utilisez la méthode `rechercher_services_souscrit_mesures(prm_id)` en passant une chaîne de caractères de 14 caractères correspondant à l'identifiant PRM du point concerné.
  7. **`CommanderArretServiceSouscritMesures`**
     Permet d'arrêter un service de collecte ou de transmission de mesures récurrente. Utilisez la méthode `commander_arret_service_souscrit_mesures(demande_arret)` en passant un objet de type `DemandeArret` en argument.
  8. **`CommandeAccesDonneesMesures`**
     Permet de demander l'accès à des données de mesures sur un point. Utilisez la méthode `commande_acces_donnees_mesures(demande)` en passant un objet de type `DemandeAccesDonneesMesures` en argument.
  9. **`M023InformationsTechniquesEtContractuelles`**
     Permet de demander les données techniques et contractuelles d'un ou plusieurs sites. Utilisez la méthode `m023(demande)` en passant un objet de type `DemandeInformationsTechniquesEtContractuelles` en argument.
  10. **`M023HistoriqueMesuresFines`**
     Permet de demander les données fines de consommation ou de production. Utilisez la méthode `m023(demande)` en passant un objet de type `DemandeHistoriqueMesuresFines` en argument.
  11. **`M023MesuresFacturantes`**


pkgId: 928c9809d353d609a3d9f74d43751d8f958eaee1776b9a969521606eb7cacab0
name: python-wsp-matrix-butler-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for wsp-matrix-butler
url: https://github.com/wsp-sag/wsp-matrix-butler
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wsp-matrix-butler-2.0.0-1.src.rpm
location_href: Packages/python-wsp-matrix-butler-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Conda Latest Release](https://anaconda.org/wsp_sap/wsp-matrix-butler/badges/version.svg)](https://anaconda.org/wsp_sap/wsp-matrix-butler)
  [![Conda Last Updated](https://anaconda.org/wsp_sap/wsp-matrix-butler/badges/latest_release_date.svg)](https://anaconda.org/wsp_sap/wsp-matrix-butler)
  [![Platforms](https://anaconda.org/wsp_sap/wsp-matrix-butler/badges/platforms.svg)](https://anaconda.org/wsp_sap/wsp-matrix-butler)
  [![License](https://anaconda.org/wsp_sap/wsp-matrix-butler/badges/license.svg)](https://github.com/wsp-sag/wsp-matrix-butler/blob/master/LICENSE)

  A SQLite-based mini-file system for organizing matrix files for MTO's Greater Golden Horseshoe Model



  Matrix Butler can be installed with conda by running:

  ```batch
  conda install -c wsp_sap wsp-matrix-butler
  ```



  > [!IMPORTANT]
  > As of v2.0, this package is imported using `wsp_matrix_butler` instead of `matrix_butler`

  ```python
  from wsp_matrix_butler import MatrixButler


  butler = MatrixButler.connect("path/to/cache")


  butler.list_matrices()
  ```



  Development of the MatrixButler uses [pixi](https://pixi.sh/) for Python package management and [rattler-build](https://rattler.build/) for package building.


pkgId: 21f03e7cb5001c1177d94399ef42bdd6ba78abe77cfce12d619f0c04b20f8c52
name: python-wsqlite3-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for wsqlite3
url: https://pypi.org/project/wsqlite3/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wsqlite3-0.5.3-1.src.rpm
location_href: Packages/python-wsqlite3-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
    <div style="padding:10px;display:flex;align-items:end">
      <div style="display:inline-block">
        <a href="https://srccircumflex.github.io/wsqlite3">
          <img src="https://raw.githubusercontent.com/srccircumflex/wsqlite3/main/docs/logo.png" alt="logo" style="display:inline-block">
        </a>
      </div>
      <div style="display:inline-block">
        <h1>
          <span style="color:#266ed9">W</span><span style="border-bottom:1px solid #266ed9"><span style="color:#266ed9">S</span><span>QL</span><span>ite3</span></span>
          <code>(v0.5 under development)</code>
        </h1>
      </div>
    </div>

    <div style="padding-left: 30px;border-left: 3px solid #d92661;background: #d9262654;">
      <p>
        versions <b><0.5</b> are <b>dysfunctional</b>
      </p>
    </div>

  ```commandline
  python -m pip install wsqlite3 --upgrade
  ```


    <p>
      <b>WSQLite3</b> (<cite>WebSocket SQLite3</cite>) is a simple and lightweight solution to manage
      access from multiple processes (or threads) to <b>SQLite3</b> databases.
    </p>

    <span><b><cite>What it is and what it is not:</cite></b></span>
    <div style="padding-left:30px;border-left:3px solid #266ed9">
      <p>
        The focus of <b>WSQLite3</b> is on simple local session management of multiple instances of a program or
        compatibilization of different programs. <b>WSQLite3</b> is not intended as a database in a wide-ranging system for
        multiple end users. For this, other advanced database systems with client servers should be used.
      </p>
      <p>
        <mark>
          <b>WSQLite3</b> in the basic version is designed for <cite>friendly</cite> connections,
          an SSL is NOT implemented and there is NO permission handling
          (Caution: <b>WSQLite3</b> also allows remote code execution).
        </mark>
      </p>
    </div>
    <span><b><cite>How it works and properties:</cite></b></span>
    <div style="padding-left:30px;border-left:3px solid #266ed9">
      <p>
        <b>WSQLite3</b> manages connections to <b>SQLite3</b> databases for multiple clients per server.
        The communication via the <b>WebSocket</b> protocol with <b>JSON</b> data provides simple and high compatibility
        between different programs and programming languages.
        The focus of the project is on the <b>WSQLite3 service</b>, which is intended as an independent process.
        For complex projects, a separate implementation of the client side should be embedded.
      </p>
    </div>








  <a href="https://pypi.org/project/wsqlite3" target="_blank" style="position: absolute;top: 22px; right: 62px;color: #db54d9; z-index:100;">
  <img src="https://pypi.org/static/images/logo-small.8998e9d1.svg" alt="pypi.org/wsqlite3" style="height: 24px;">
  </a>




  <hr>
  <p>
    <a href="https://srccircumflex.github.io/wsqlite3"><b> &#9654; &nbsp; Documentation</b></a>
  </p>


pkgId: 237c60f9fb342d70b94ace1b26f615522e3ba1608b8d9ecfc3a32706b74892e7
name: python-wtlike-help
arch: noarch
version: 0.10.5
epoch: 0
release: 1
summary: Development documents and examples for wtlike
url: https://github.com/tburnett/wtlike/tree/master/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wtlike-0.10.5-1.src.rpm
location_href: Packages/python-wtlike-help-0.10.5-1.noarch.rpm
checksum_type: sha256
description:
  > Quickly create a light curve for any 4FGL source, on any time scale, with optional Bayesian Block analysis



  [this document](https://tburnett.github.io/wtlike/),   [the repository](https://github.com/tburnett/wtlike)


  `wtlike`(Perhaps pronounced "DUB-Tee-like"), is a library optimized for interactive exploration in a [Jupyter notebook](https://jupyter.org/) with access to all Fermi-LAT data, and to analyze the time dependence of any source in the
  4FGL catalog on any time scale, with the option of performing a [Bayesian Block](https://arxiv.org/pdf/1207.5578.pdf)  partition to select optimal time intervals. The source can be identified by the 4FGL name, or any equivalent common name.

  Here is a minimal demo:

  ```python
  from wtlike import *
  config = Config()
  valid = config.valid
  if valid:
      with Timer() as t:
          wtl = WtLike('3C 273',week_range=(9,3*52+9))
          print(t)
  ```

      SourceData:  4FGL J1229.0+0202: Restoring from cache with key "P88Y3157_weeks_9-165"
      SourceData: Source 3C 273 with:
      	 data:        33,210 photons from 2008-08-04 to 2011-08-03
      	 exposure:   713,320 intervals,  average effective area 2783 cm^2 for 21.3 Ms
      	 rates:  source 2.02e-07/s, background 3.58e-07/s,
      CellData.rebin: Bin photon data into 156 1-week bins from 54683.0 to 55775.0
      LightCurve: select 156 cells for fitting with e>35 & n>2
      elapsed time: 0.7s (0.0 min)


  This created a `WtLike` object, loading the first 3 years of data, by specifying weeks from #9, the first data-taking week.
  The reason to specify only the first three years here is to avoid the 10 min or so that extracting the furl 13+ years would take for this demo. If that had already been done, then using an included [cache system](https://tburnett.github.io/wtlike/config.html#Cache), it only has to be done once.

  Now ask it to make a plot:

  ```python
  if config.valid:
      wtl.plot(UTC=1);
  ```



  ![png](docs/images/output_3_0.png)



  This assumes that the name for the source, in this case the historically famous first [quasar](https://en.wikipedia.org/wiki/Quasar#Background) to be discovered, can be associated with a 4FGL catalog source. The plot shows, as a function of UTC (or MJD if desired) time, weekly measurements of deviations of the flux relative to the average of the 12-year interval used to define the 4FGL-DR3 catalog.





  This package has code that was developed with the [nbdev](https://nbdev.fast.ai/) code/tests/documentation environment from the [github package lat-timing](https://github.com/tburnett/lat-timing) to generate light curves of Fermi-LAT sources.
  It is based on a [paper](https://arxiv.org/pdf/1910.00140.pdf) by Matthew Kerr, which derives the [weighted likelihood formalism](https://tburnett.github.io/wtlike/loglike#The-Kerr-likelihood-formula) used here, specifically with
  the [Bayesian Block](https://arxiv.org/pdf/1207.5578.pdf) to detect and characterize variability of a gamma-ray source.

  There are several innovative design features that significantly improve the speed and portability.

  * Condensed photon and spacecraft data.
  * Weight tables
  * A cache to improve interactivity
  * Likelihood functions fit to a modified Poisson function
  * Unbinned likelihood
  * A simple user interface




  Historically, gamma-ray source measurements have used two methods:
  1. For a fixed time interval, where the energy and
  position are used, with a model including all potential sources and a model of the detector response to
  define the likelihood. This has been the only way to study weak sources. A light curve must apply this to
  each time interval.
  2. Or, for very bright flares, for example GRBs or AGN flares, one can simply count the number of photons within a
  circular region, that is, aperture photometry.

  Matthew Kerr [introduced](https://arxiv.org/pdf/1910.00140.pdf) a third method, basically counting photons but using information from a static
  likelihood analysis to assign a "weight" to each photon, the probability for being from the source in question, then optimizing this likelihood. This assumes that the only thing changing is the flux of
  the source.  He calls it "retrospective", since the analysis for the full time is then applied back to the individual photons. Another way of looking at it is to make the assumption that the time dependence of a source's photon flux factorizes according to the energy and spatitial dependences.



  In a significant modification from Kerr's implemetation as described in that paper, we evaluate weights for each photon by a table lookup.

  Assumptions:
  * Source photons are completely contained in the dataset boundaries (the "ROI").
  * The instrument response is constant with time.
  * The background pattern is constant. (Clearly violated if a neighboring source varies!)

  The likelihood evaluation is implemented in the module  [loglike](https://tburnett.github.io/wtlike/loglike).



  *Fermi* data are retrieved from the Fermi-LAT weekly data files extracted from the [GSFC FTP server](https://heasarc.gsfc.nasa.gov/FTP/fermi/data/lat/weekly),
  with subfolders for the photon data, `photon` and spacecraft data, `spacecraft`. It is [described here](http://fermi.gsfc.nasa.gov/ssc/data/access/http://fermi.gsfc.nasa.gov/ssc/data/access/). The files are organized into individual weeks, starting UTC midnight each Thursday. Files for the most recent week are updated daily.

  We convert each pair of photon and spacecraft files to two DataFrame tables with the minimum information needed to evaluate the likelihood, as compressed as possible. Particularly, the energy and position are binned. Details can be seen in the module [data_man](https://tburnett.github.io/wtlike/data_man).

  The entire data set (SOURCE class, energy>100 MeV) in this format occupies ~2 GB.



  All further processing uses a subset of the photons within a cone, currently $4^\circ$, about the selected source, and
  evaluates the exposure during 30-s intervals for this direction.  In the class
  [`SourceData`](https://tburnett.github.io/wtlike/source_data#SourceData), implemented in the module
  [`source_data`](https://tburnett.github.io/wtlike/source_data) we
  1. Extract photons
  2. Evaluate exposure, using the effective area tables and a spectral assumption.
  3. Determine the weight for each photon, using the table for the source. See the module [weights](https://tburnett.github.io/wtlike/weights) for details.

  The result is a photon DataFrame, containing for each photon, the time $t$ in MJD units, $w$.

  This class is a superclass of the user interface class `WtLike` introduced above.



  A "cell", the terminology used by Kerr, the set of photons in a specific time interval. The class
  [CellData](https://tburnett.github.io/wtlike/cell_data#CellData)
  in the module [cell_data](https://tburnett.github.io/wtlike/cell_data), a subclass of SourceData manages this.

  This class is instantiated with a tuple to define the binning in time. Denoted by `(a, b, c)`, the elements are:
  * `a`--start time
  * `b`--stop time
  * `c`-- bin size in days, but 0 means orbit-based, intervals are contiguous eposure.

  For the start and stop, values > 50000 are interpreted as MJD. Otherwise they are relative to start if positive
  or stop if negative for the full dataset, both rounded to a full day. Zero means actual start for `a` and stop for `b`.
  The default binning is simply `(0, 0, 7)` for weekly bins with the full dataset. Hourly for the most recent week would be `(-7, 0, 1/24)`.

  A DataFrame table of the cells is created as a data member `cells`, with content

  * `t` -- MJD time at cell center
  * `tw` -- cell width in days
  * `e` -- cell exposure, for reference
  * `n` -- the number of photons
  * `w` -- a list of `n` weights
  * `S` -- expected number source photons, the nominal source rate times the total exposure.
  * `B` -- expected number of background photons (unused)



  `CellData` implements a method `view`, which accepts a binning tuple as an argument, returns a *copy* of the current object, which can be a subclass, assigning to it the binning. Thus the view has all the attributes of its parent, but
  with a different set of cells.

  So the following creates a new WtLike object that we generated above, rebins a copy with 25-day bins in the first 100 days, generates a list of the cells, then removes it since it wasn't assigned a reference variable.


  ```python
  if config.valid:
      print(wtl.view(0,100,25).cells)
  ```

      CellData.rebin: Bin photon data into 4 25-day bins from 54683.0 to 54783.0
      LightCurve: select 4 cells for fitting with e>125 & n>2
               t    tw            e     n  \
      0  54695.5  25.0  1488.182373   553
      1  54720.5  25.0  1868.273926  1438
      2  54745.5  25.0  1450.828979  1183
      3  54770.5  25.0  1929.570801  1175

                                                         w           S           B
      0  [4.8901367e-01, 0.8066406, 0.11303711, 0.19165...  300.871887  532.046936
      1  [0.4345703, 0.6064453, 0.0690918, 0.056274414,...  377.716553  667.935242
      2  [0.33911133, 0.3100586, 0.7089844, 0.06994629,...  293.320007  518.692566
      3  [0.09112549, 0.58251953, 0.07537842, 0.3457031...  390.109192  689.849792




  The class [`LightCurve`](https://tburnett.github.io/wtlike/lightcurve), implemented in the module [`lightcurve`](https://tburnett.github.io/wtlike#LightCurve) is a subclass of `SourceData`.
  An instance invokes its superclass to generate the set of cells, then evaluates the likelihoods.


  We fit the likelihood for each cell, using only a few evaluations, to a [3-parameter Poisson-like formula](https://tburnett.github.io/poisson). Two advantages of this are:
  * efficiency -- for large numbers of photons, this is much faster
  * convenience -- the [`Poisson`](https://tburnett.github.io/wtlike/poisson.html#Poisson) object implements functions that return the TS, 95% CL, maximum, and uncertainties, using the [incomplete gamma function](https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.gammainc.html).

  This results in a DataFrame `fits` containing
  * `t, tw, n`, from the cell, and
  * `fit`, the `Poisson` object



  The function `Likelihood.plot` actually invokes [`flux_plot`](https://tburnett.github.io/lightcurve#flux_plot)


  The class [`WtLike`](https://tburnett.github.io/wtlike/90-main.html#WtLike),
  implememted in the module [`main`](https://tburnett.github.io/wtlike/90-main.html), adds an implementation of the Bayesian Block (BB) algorithm, from the module [`bayesian`](https://tburnett.github.io/wtlike)  using likelihood instead of counts.
  There we have two subclasses of `astropy.stats.bayesian_blocks`, [`CountFitness`](https://tburnett.github.io/wtlike/bayesian.html#CountFitness) and the default [`LikelihoodFitness`](https://tburnett.github.io/wtlike/bayesian.html#LikelihoodFitness).

  This code creates partitions between boundaries of a set of cells. Usage is via a special view,
  [bb_view`](https://tburnett.github.io/wtlike/main#WtLike.bb_view)


  ```python
  if config.valid:
      bb = wtl.bb_view()
      bb.plot(UTC=1);
  ```

      Bayesian Blocks: partitioning 156 cells using LikelihoodFitness with penalty 5%
      	found 43 / 156 blocks.
      LightCurve: Loaded 43 / 43 cells for fitting




  ![png](docs/images/output_14_1.png)



  As you see, this made 94 blocks from the 656 weeks, fit each, and overplotted in on the weekly light curve.
  <details class="description">
      <summary>Code details ...</summary>

  ```python


  @ipynb_doc
  def pgram(wtl):
      """
      

      One can analyze the frequency spectrum by generating a
      [Kerr periodogram](https://arxiv.org/pdf/1910.00140.pdf).
      A `WtLike` object has a `periodogram` function that returns a `TimeSeries` object.
      {out}
      {fig}
      """
      with capture_hide('Setup output') as out:
          p =wtl.periodogram()
          p.power_plot(pmax=100 );
      fig = plt.gcf()
      return locals()

  if config.valid: pgram(wtl)
  ```

  </details>




  One can analyze the frequency spectrum by generating a
  [Kerr periodogram](https://arxiv.org/pdf/1910.00140.pdf).
  A `WtLike` object has a `periodogram` function that returns a `TimeSeries` object.
  <details  class="nbdoc-description" >  <summary> Setup output </summary>  <div style="margin-left: 5%;"><pre>CellData.rebin: Bin photon data into 26256 1-hour bins from 54683.0 to 55777.0<br></pre></div> </details>
  <figure style="margin-left: 5%" title="Figure 1">   <img src="data:image/png;base64,[encoded data, 23856 characters]" alt="Figure 1"  <br> </figure>


  <details class="description">
      <summary>Code details ...</summary>

  ```python


  @ipynb_doc
  def aitdemo(week, nside, name='3C 454.3', size=40):
      """
      

      Choose week {week}, with a large 3C 454.3 flare.

      The all-sky Aitoff image of the photon count map, counts per nside={nside} pixel.
      {fig1}

      And zoom to small region, with a ZEA projection, a ${size}^\circ$ square.
      {fig2}
      """
      from wtlike.skymaps import  SquareWCS
      from wtlike.sources import findsource
      from utilities import healpix as hpx

      cntmap = DataView( FermiInterval(7)[week-1], nside=nside).count_map()

      kw = dict(vmin=1, vmax=100, )
      fig1 = hpx.HPmap(cntmap, f'week {week}', unit='counts/pixel', sigma=0.5).ait_plot(**kw);

      wcs = SquareWCS(findsource(name, gal=True), size=size,)
      fig2 = wcs.plot(cntmap, title=name,  cb_kw=dict( shrink=0.8), **kw)
      return locals()


  week=79
  nside=64

  if valid: aitdemo(week, nside, fignum=1)
  ```

  </details>




  Choose week 79, with a large 3C 454.3 flare.

  The all-sky Aitoff image of the photon count map, counts per nside=64 pixel.
  <figure style="margin-left: 5%" title="Figure 1">   <img src="data:image/png;base64,[encoded data, 208484 characters]" alt="Figure 1"  <br> </figure>

  And zoom to small region, with a ZEA projection, a $40^\circ$ square.
  <figure style="margin-left: 5%" title="Figure 2">   <img src="data:image/png;base64,[encoded data, 110152 characters]" alt="Figure 2"  <br> </figure>





  Finally, a simulation option is available. See the [tutorial](https://tburnett.github.io/wtlike/tutorial/)  for an example



  Note that this is in beta mode.
  It depends on the packages:  matplotlib, pandas, scipy, astropy, scipy and healpy, which pip will install if needed.

  To install from pyPI:

  ```
  pip install wtlike
  ```
  or to upgrade:
  ```
  pip install -U wtlike
  ```




  There are three data sources which `wtlike` needs to function:

  -	The photon/spacecraft data, one file per week
  -	A table of weights for each source
  -	An effective area table, a grid in energy/angle for "front" and "back" events

  These must be found in a folder, which by default is `~/wtlike-data`. In that folder there must be (perhaps links to) three folders named `data_files`, `weight_files`, `aeff_files`, and a zip file, `weight_file.zip`.  A current copy can be found in my [Google Drive](https://drive.google.com/drive/folders/1YxQRpZ4MI945-GZ2bK3CgTo6ViqoQ2Xt?lfhs=2).



  An easy way to test, or even use, this system is with [Goggle's colab](https://colab.research.google.com/). To use it, you need a Google account.
  All the data files are in my shared folder [wtlike-data](https://drive.google.com/drive/folders/1YxQRpZ4MI945-GZ2bK3CgTo6ViqoQ2Xt?lfhs=2).
  It includes a [setup notebook](https://colab.research.google.com/drive/1Dy29VRE3M28W_uMJruDxrBElFpyg0Iyl) which demonstrates setting up a free Google-hosted VM to run wtlike code and makes a few demo plots.


